Upload folder using huggingface_hub

.env

@@ -0,0 +1 @@
+API_KEY='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'

.env.example

@@ -0,0 +1 @@
+API_KEY=

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1 @@
+.env

README.md

@@ -1,12 +1,6 @@
 ---
-title: Chat Bot Test
-emoji: 🦀
-colorFrom: green
-colorTo: yellow
+title: chat-bot-test
+app_file: work-app.py
 sdk: gradio
 sdk_version: 3.35.2
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,28 @@
+import gradio as gr
+import random
+import time
+
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox()
+    clear = gr.ClearButton([msg, chatbot])
+
+    def user(user_message, history):
+        return gr.update(value="", interactive=False), history + [[user_message, None]]
+
+    def bot(history):
+        bot_message = random.choice(["How are you?", "I love you", "I'm very hungry"])
+        print(f"{'*'*1000} {history}")
+        history[-1][1] = ""
+        for character in bot_message:
+            history[-1][1] += character
+            time.sleep(0.05)
+            yield history
+
+    response = msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, chatbot, chatbot
+    )
+    response.then(lambda: gr.update(interactive=True), None, [msg], queue=False)
+
+demo.queue()
+demo.launch()

backend.py

@@ -0,0 +1,56 @@
+import openai
+import gradio as gr
+from typing import List, Dict
+import click
+
+# load .env
+import os
+from dotenv import load_dotenv
+from pprint import pprint
+
+import openai
+
+load_dotenv()
+
+
+openai.api_key = os.getenv("API_KEY")
+
+
+message_history = []
+cost = 0
+
+
+def add_text(user_input: str, history: List, system_role: str = "You are a great assistant"):
+    global message_history
+    message_history += [{"role": "system", "content": f"{system_role}"}]
+    message_history += [{"role": "user", "content": user_input}]
+    return gr.update(value="", interactive=False), history + [[user_input, ""]]
+
+
+def generate_response(history: List, model="gpt-3.5-turbo"):
+    global message_history, cost
+
+    completion = openai.ChatCompletion.create(
+        model=model,
+        messages=message_history,
+    )
+
+    reply_content = completion["choices"][0]["message"]["content"]
+    cost += completion.usage.total_tokens * (0.002 / 1_000)
+
+    message_history += [{"role": "assistant", "content": reply_content}]
+
+    for char in reply_content:
+        history[-1][1] += char
+        yield history
+
+
+def calc_cost():
+    global cost
+    return round(cost, 4)
+
+
+if __name__ == "__main__":
+    add_text()
+    generate_response()
+    calc_cost()

chatbot.py

@@ -0,0 +1,90 @@
+import os
+import re
+from dotenv import load_dotenv
+
+import openai
+import gradio as gr
+
+load_dotenv()
+
+openai.api_key = os.getenv("API_KEY")
+
+
+def chat(
+    user_input: str,
+    message_history=[],
+    role="user",
+    model="gpt-3.5-turbo",
+):
+    message_history.append(
+        {"role": "system", "content": "You are a helpful assistant."}
+    )
+    message_history.append({"role": role, "content": f"{user_input}"})
+
+    completion = openai.ChatCompletion.create(
+        model=model,
+        messages=message_history,
+    )
+
+    reply_content = completion.choices[0].message.content
+    message_history.append({"role": "assistant", "content": f"{reply_content}"})
+
+    # conversation_display = "\n\n".join(
+    #     [
+    #         f"{message['role']}: {message['content']}"
+    #         for message in message_history
+    #         if message["role"] != "system"
+    #     ]
+    # )
+    # return reply_content, conversation_display
+
+    response = [
+        (message_history[i]["content"], message_history[i + 1]["content"])
+        for i in range(2, len(message_history) - 1, 2)
+    ]  # convert to tuples of list
+    return response
+
+
+# Create the Gradio interface
+# iface = gr.Interface(
+#     fn=chat,
+#     inputs=gr.Textbox(placeholder="Enter your message..."),
+#     outputs=[
+#         gr.Textbox(label="Assistant Reply"),
+#         gr.Textbox(label="Conversation History"),
+#     ],
+# )
+
+# creates a new Blocks app and assigns it to the variable demo.
+with gr.Blocks() as demo:
+    # creates a new Chatbot instance and assigns it to the variable chatbot.
+    chatbot = gr.Chatbot()
+
+    # creates a new Row component, which is a container for other components.
+    with gr.Row():
+        """creates a new Textbox component, which is used to collect user input.
+        The show_label parameter is set to False to hide the label,
+        and the placeholder parameter is set"""
+        txt = gr.Textbox(
+            show_label=False, placeholder="Enter text and press enter"
+        ).style(container=False)
+    """
+    sets the submit action of the Textbox to the predict function, 
+    which takes the input from the Textbox, the chatbot instance, 
+    and the state instance as arguments. 
+    This function processes the input and generates a response from the chatbot, 
+    which is displayed in the output area."""
+    txt.submit(chat, txt, chatbot)  # submit(function, input, output)
+    # txt.submit(lambda :"", None, txt)  #Sets submit action to lambda function that returns empty string
+
+    """
+    sets the submit action of the Textbox to a JavaScript function that returns an empty string. 
+    This line is equivalent to the commented out line above, but uses a different implementation. 
+    The _js parameter is used to pass a JavaScript function to the submit method."""
+    txt.submit(
+        None, None, txt, _js="() => {''}"
+    )  # No function, no input to that function, submit action to textbox is a js function that returns empty string, so it clears immediately.
+
+
+if __name__ == "__main__":
+    demo.launch()

notebook.ipynb

@@ -0,0 +1,397 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gradio as gr\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "import openai\n",
+    "\n",
+    "load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "openai.api_key = os.getenv('API_KEY')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "completion = openai.ChatCompletion.create(\n",
+    "    model=\"gpt-3.5-turbo\",\n",
+    "    messages=[{\"role\": \"user\", \"content\": \"Is Nigeria a great country?\"}],\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<OpenAIObject chat.completion id=chatcmpl-7TzbaXbPEpF3WRiRpj37LmLyGkvur at 0x7f18dbf1a510> JSON: {\n",
+      "  \"id\": \"chatcmpl-7TzbaXbPEpF3WRiRpj37LmLyGkvur\",\n",
+      "  \"object\": \"chat.completion\",\n",
+      "  \"created\": 1687382678,\n",
+      "  \"model\": \"gpt-3.5-turbo-0301\",\n",
+      "  \"choices\": [\n",
+      "    {\n",
+      "      \"index\": 0,\n",
+      "      \"message\": {\n",
+      "        \"role\": \"assistant\",\n",
+      "        \"content\": \"As an AI language model, I do not have personal opinions. However, Nigeria has many great qualities such as rich cultural heritage, abundant natural resources, and diverse economy. However, like any country, it faces its own set of challenges such as political instability, corruption, and poverty. Ultimately, whether Nigeria is seen as a great country is subjective and depends on individual perspectives and experiences.\"\n",
+      "      },\n",
+      "      \"finish_reason\": \"stop\"\n",
+      "    }\n",
+      "  ],\n",
+      "  \"usage\": {\n",
+      "    \"prompt_tokens\": 14,\n",
+      "    \"completion_tokens\": 77,\n",
+      "    \"total_tokens\": 91\n",
+      "  }\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from pprint import pprint\n",
+    "\n",
+    "pprint(completion)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "('As an AI language model, I do not have personal opinions. However, Nigeria '\n",
+      " 'has many great qualities such as rich cultural heritage, abundant natural '\n",
+      " 'resources, and diverse economy. However, like any country, it faces its own '\n",
+      " 'set of challenges such as political instability, corruption, and poverty. '\n",
+      " 'Ultimately, whether Nigeria is seen as a great country is subjective and '\n",
+      " 'depends on individual perspectives and experiences.')\n"
+     ]
+    }
+   ],
+   "source": [
+    "pprint(completion.choices[0].message.content)\n",
+    "# pprint(completion['choices'][0]['message']['content'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Veronica\n"
+     ]
+    }
+   ],
+   "source": [
+    "message_history = []\n",
+    "\n",
+    "user_input = input(\"> \")\n",
+    "print(user_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "message_history.append({\"role\": \"user\", \"content\": f\"{user_input}\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Veronica is a name of Latin origin that means \"true image\" or \"image of God.\" It is a popular name for girls and has been used in many different cultures and countries. The name can be shortened to various nicknames, including Roni, Vero, and Nica. Some notable people with the name Veronica include actress Veronica Lake, singer Veronica Maggio, and Saint Veronica, a woman who according to Christian tradition wiped the face of Jesus as he carried the cross.\n"
+     ]
+    }
+   ],
+   "source": [
+    "completion = openai.ChatCompletion.create(\n",
+    "    model=\"gpt-3.5-turbo\",\n",
+    "    messages=message_history,\n",
+    ")\n",
+    "\n",
+    "reply_content = completion.choices[0].message.content\n",
+    "print(reply_content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "('Veronica is a name of Latin origin that means \"true image\" or \"image of '\n",
+      " 'God.\" It is a popular name for girls and has been used in many different '\n",
+      " 'cultures and countries. The name can be shortened to various nicknames, '\n",
+      " 'including Roni, Vero, and Nica. Some notable people with the name Veronica '\n",
+      " 'include actress Veronica Lake, singer Veronica Maggio, and Saint Veronica, a '\n",
+      " 'woman who according to Christian tradition wiped the face of Jesus as he '\n",
+      " 'carried the cross.')\n"
+     ]
+    }
+   ],
+   "source": [
+    "pprint(reply_content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "message_history.append({\"role\": \"assistant\", \"content\": f\"{reply_content}\"})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User input was: Which other similar names\n",
+      "\n",
+      "\n",
+      "('Similar names to Veronica include:\\n'\n",
+      " '\\n'\n",
+      " '- Victoria\\n'\n",
+      " '- Vanessa\\n'\n",
+      " '- Valentina\\n'\n",
+      " '- Vivian\\n'\n",
+      " '- Verity\\n'\n",
+      " '- Verna\\n'\n",
+      " '- Vera\\n'\n",
+      " '- Vincentia\\n'\n",
+      " '- Vittoria\\n'\n",
+      " '- Venetia')\n"
+     ]
+    }
+   ],
+   "source": [
+    "user_input = input(\"> \")\n",
+    "print(f'User input was: {user_input}')\n",
+    "print('\\n')\n",
+    "\n",
+    "message_history.append({\"role\": \"user\", \"content\": f\"{user_input}\"})\n",
+    "\n",
+    "completion = openai.ChatCompletion.create(\n",
+    "    model=\"gpt-3.5-turbo\",\n",
+    "    messages=message_history,\n",
+    ")\n",
+    "\n",
+    "reply_content = completion.choices[0].message.content\n",
+    "pprint(reply_content)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "User input was: Iphone or android?\n",
+      "\n",
+      "\n",
+      "(\"Sorry, as an AI language model, I don't have personal preferences. It \"\n",
+      " 'depends on your personal preference and needs. Both iPhone and Android have '\n",
+      " 'their own advantages and disadvantages. iPhone has a more streamlined and '\n",
+      " 'user-friendly interface, while Android offers more customization options and '\n",
+      " 'a wider range of models and prices. Both platforms are great for content '\n",
+      " 'creation, so it really comes down to your personal preference and budget.')\n",
+      "User input was: Samsung or Tecno\n",
+      "\n",
+      "\n",
+      "('In terms of quality and features, Samsung is generally known to be a better '\n",
+      " 'brand compared to Tecno. Samsung offers a wide range of options for '\n",
+      " 'different budgets and needs, from mid-range to high-end smartphones with '\n",
+      " 'advanced cameras, processors, and other features that are great for content '\n",
+      " 'creation. \\n'\n",
+      " '\\n'\n",
+      " 'While Tecno also offers affordable smartphones, they may not have as many '\n",
+      " 'premium features as Samsung, and their cameras may not be as advanced. '\n",
+      " 'However, Tecno can still be a good option if you are on a tight budget. '\n",
+      " 'Ultimately, the choice between Samsung and Tecno depends on your personal '\n",
+      " 'preferences and needs.')\n"
+     ]
+    }
+   ],
+   "source": [
+    "message_history = []\n",
+    "\n",
+    "def chat(user_input: str, system: str=None, role='user', model=\"gpt-3.5-turbo\"):\n",
+    "    if system:\n",
+    "        message_history.append({\"role\": 'system', \"content\": f\"{system}\"})\n",
+    "    message_history.append({\"role\": role, \"content\": f\"{user_input}\"})\n",
+    "\n",
+    "    completion = openai.ChatCompletion.create(\n",
+    "        model=model,\n",
+    "        messages=message_history,\n",
+    "    )\n",
+    "\n",
+    "    reply_content = completion.choices[0].message.content\n",
+    "    message_history.append({\"role\": \"assistant\", \"content\": f\"{reply_content}\"})\n",
+    "    return reply_content\n",
+    "\n",
+    "\n",
+    "for _ in range(2):\n",
+    "    user_input = input('--> ')\n",
+    "    print(f'User input was: {user_input}')\n",
+    "    print('\\n')\n",
+    "    \n",
+    "    pprint(chat(user_input, system='You are a content creator on YouTube'))\n",
+    "    print('\\n')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/alli/miniconda3/envs/openai/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "/home/alli/miniconda3/envs/openai/lib/python3.11/site-packages/gradio/inputs.py:27: UserWarning: Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\n",
+      "  warnings.warn(\n",
+      "/home/alli/miniconda3/envs/openai/lib/python3.11/site-packages/gradio/inputs.py:30: UserWarning: `optional` parameter is deprecated, and it has no effect\n",
+      "  super().__init__(\n",
+      "/home/alli/miniconda3/envs/openai/lib/python3.11/site-packages/gradio/inputs.py:30: UserWarning: `numeric` parameter is deprecated, and it has no effect\n",
+      "  super().__init__(\n",
+      "/home/alli/miniconda3/envs/openai/lib/python3.11/site-packages/gradio/outputs.py:22: UserWarning: Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" 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": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "# Create the Gradio interface\n",
+    "iface = gr.Interface(\n",
+    "    fn=chat,\n",
+    "    inputs=gr.inputs.Textbox(placeholder=\"Enter your message...\"),\n",
+    "    outputs=gr.outputs.Textbox()\n",
+    ")\n",
+    "\n",
+    "# Start the interface\n",
+    "iface.launch()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "openai",
+   "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.4"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,3 @@
+gradio==3.35.2
+openai==0.27.8
+python-dotenv==1.0.0

simple-app.py

@@ -0,0 +1,18 @@
+import gradio as gr
+import random
+import time
+
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox()
+    clear = gr.ClearButton([msg, chatbot])
+
+    def respond(message, chat_history):
+        bot_message = random.choice(["How are you?", "I love you", "I'm very hungry"])
+        chat_history.append((message, bot_message))
+        time.sleep(2)
+        return "", chat_history
+
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
+
+demo.launch()

test.py

@@ -0,0 +1,32 @@
+import gradio as gr
+
+
+def sentence_builder(quantity, animal, countries, place, activity_list, morning):
+    return f"""The {quantity} {animal}s from {" and ".join(countries)} went to the {place} where they {" and ".join(activity_list)} until the {"morning" if morning else "night"}"""
+
+
+demo = gr.Interface(
+    sentence_builder,
+    [
+        gr.Slider(2, 20, value=4, label="Count", info="Choose between 2 and 20"),
+        gr.Dropdown(
+            ["cat", "dog", "bird"], label="Animal", info="Will add more animals later!"
+        ),
+        gr.CheckboxGroup(["USA", "Japan", "Pakistan"], label="Countries", info="Where are they from?"),
+        gr.Radio(["park", "zoo", "road"], label="Location", info="Where did they go?"),
+        gr.Dropdown(
+            ["ran", "swam", "ate", "slept"], value=["swam", "slept"], multiselect=True, label="Activity", info="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed auctor, nisl eget ultricies aliquam, nunc nisl aliquet nunc, eget aliquam nisl nunc vel nisl."
+        ),
+        gr.Checkbox(label="Morning", info="Did they do it in the morning?"),
+    ],
+    "text",
+    examples=[
+        [2, "cat", ["Japan", "Pakistan"], "park", ["ate", "swam"], True],
+        [4, "dog", ["Japan"], "zoo", ["ate", "swam"], False],
+        [10, "bird", ["USA", "Pakistan"], "road", ["ran"], False],
+        [8, "cat", ["Pakistan"], "zoo", ["ate"], True],
+    ]
+)
+
+if __name__ == "__main__":
+    demo.launch()

work-app.py

@@ -0,0 +1,46 @@
+import gradio as gr
+from backend import generate_response, add_text, calc_cost
+
+
+# @click.command()
+# @click.option(
+#     "-s",
+#     "--system_role",
+#     default="You are good assistant",
+#     type=str,
+#     help="Which role do you want the chatbot to take in replying your messages",
+# )
+# def app():
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        with gr.Column(scale=0.9):
+            message = gr.Textbox(
+                show_label=False,
+                placeholder="Please enter a message and press Enter",
+            )
+
+        with gr.Column(scale=0.1):
+            cost_view = gr.Number(label="Usage in $", value=0)
+
+    clear = gr.ClearButton([chatbot, message, cost_view])
+    models = gr.Radio(
+        value="gpt-3.5-turbo",
+        choices=["gpt-3.5-turbo", "gpt-3.5-turbo-0301", "gpt-3.5-turbo-16k"],
+        label="Models",
+        info="Which openai chat model to use",
+    )
+
+    response = (
+        message.submit(add_text, [message, chatbot], [message, chatbot], queue=False)
+        .then(generate_response, [chatbot, models], chatbot)
+        .then(calc_cost, outputs=cost_view)
+    )
+
+    response.then(lambda: gr.update(interactive=True), None, [message], queue=False)
+
+demo.queue()
+
+if __name__ == "__main__":
+    demo.launch()