add textbase frontend

Author: rohansx

.env

@@ -0,0 +1 @@
+OPEN_API_KEY = "sk-HHIbAZHmOmU6UC3ev56UT3BlbkFJOuixAgpEC7YGofM2bGj"

.gitignore

@@ -0,0 +1,42 @@
+# Textbase
+
+✨ Textbase is a framework for building chatbots using NLP and ML. ✨
+
+Just implement the `on_message` function in `main.py` and Textbase will take care of the rest :)
+
+Since it is just Python you can use whatever models, libraries, vector databases and APIs you want.
+
+_Coming soon:_
+
+- [ ] PyPI package
+- [ ] SMS integration
+- [ ] Easy web deployment via `textbase deploy`
+- [ ] Native integration of other models (Claude, Llama, ...)
+
+## Installation
+
+Clone the repository and install the dependencies using [Poetry](https://python-poetry.org/) (you might have to [install Poetry](https://python-poetry.org/docs/#installation) first).
+
+```bash
+git clone https://github.com/cofactoryai/textbase
+cd textbase
+poetry install
+```
+
+## Start development server
+
+> If you're using the default template, **remember to set the OpenAI API key** in `main.py`.
+
+Run the following command:
+
+```bash
+poetry run python textbase/textbase_cli.py test main.py
+```
+
+Now go to [http://localhost:4000](http://localhost:4000) and start chatting with your bot! The bot will automatically reload when you change the code.
+
+_Simpler version using PyPI package and CLI coming soon!_
+
+## Contributions
+
+Contributions are welcome! Please open an issue or a pull request.

README.md

@@ -0,0 +1,37 @@
+import textbase
+from textbase.message import Message
+from textbase import models
+import os
+from typing import List
+# Load your OpenAI API key
+models.OpenAI.api_key = ""
+# or from environment variable:
+models.OpenAI.api_key = os.getenv("OPENAI_API_KEY")
+
+# Prompt for GPT-3.5 Turbo
+SYSTEM_PROMPT = """I want you to be an AI doctor and tell me how you can help me and I don't want you to respond to irrelevant to medical terms. Please understand that you are a AI doctor and can help with anything realted to medical. Also, Please be specific and explain it like a five year child. Also please present the data systematically points by points
+"""
+
+
+@textbase.chatbot("talking-bot")
+def on_message(message_history: List[Message], state: dict = None):
+    """Your chatbot logic here
+    message_history: List of user messages
+    state: A dictionary to store any stateful information
+
+    Return a string with the bot_response or a tuple of (bot_response: str, new_state: dict)
+    """
+
+    if state is None or "counter" not in state:
+        state = {"counter": 0}
+    else:
+        state["counter"] += 1
+
+    # # Generate GPT-3.5 Turbo response
+    bot_response = models.OpenAI.generate(
+        system_prompt=SYSTEM_PROMPT,
+        message_history=message_history,
+        model="gpt-3.5-turbo",
+    )
+
+    return bot_response, state

__pycache__/main.cpython-311.pyc

@@ -0,0 +1,27 @@
+[tool.poetry]
+name = "textbase"
+version = "0.1.0"
+description = "A python library to help you create chatbots easily with some more configurations"
+authors = ["kaus-cofactory <[email protected]>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.8.1"
+requests = "^2.31.0"
+openai = "^0.27.8"
+twilio = "^8.5.0"
+python-dotenv = "^1.0.0"
+langchain = "^0.0.239"
+pinecone-client = "^2.2.2"
+chromadb = "^0.4.2"
+guardrails-ai = "^0.1.8"
+llama-index = "^0.7.11.post1"
+jinja2 = "^3.1.2"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+textbase = "textbase.textbase_cli:cli"

main.py

@@ -0,0 +1,20 @@
+class ChatbotRegistry:
+    _registry = {}
+
+    @classmethod
+    def register(cls, bot_name):
+        def decorator(func):
+            cls._registry[bot_name] = func
+            return func
+        return decorator
+
+    @classmethod
+    def get_bot(cls, bot_name):
+        return cls._registry.get(bot_name, None)
+
+registry = ChatbotRegistry()
+
+def chatbot(bot_name):
+    return registry.register(bot_name)
+
+

poetry.lock

@@ -0,0 +1,112 @@
+# textbase/backend.py
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+from textbase.message import Message
+from dotenv import load_dotenv
+import os
+from fastapi.middleware.cors import CORSMiddleware
+import sys
+import logging
+from typing import List
+import importlib
+
+logging.basicConfig(level=logging.INFO)
+
+load_dotenv()
+
+from .message import Message
+
+app = FastAPI()
+
+origins = [
+    "http://localhost:3000",
+    "http://localhost:4000",
+    "http://localhost:5173",
+    "*",
+]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/", response_class=HTMLResponse)
+async def read_root():
+    """
+    The `read_root` function reads and returns the contents of an HTML file specified by the path
+    "textbase/frontend/index.html".
+    :return: The content of the "index.html" file located in the "textbase/frontend" directory is being
+    returned.
+    """
+    with open("textbase/frontend/dist/index.html") as f:
+        return f.read()
+
+
+def get_module_from_file_path(file_path: str):
+    """
+    The function `get_module_from_file_path` takes a file path as input, loads the module from the file,
+    and returns the module.
+
+    :param file_path: The file path is the path to the Python file that you want to import as a module.
+    It should be a string representing the absolute or relative path to the file
+    :type file_path: str
+    :return: the module that is loaded from the given file path.
+    """
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+@app.post("/chat", response_model=dict)
+async def chat(messages: List[Message], state: dict = None):
+    """
+    The above function is a Python API endpoint that receives a list of messages and a state dictionary,
+    loads a module from a file path, calls the on_message function from the module with the messages and
+    state, and returns the bot messages generated by the module.
+
+    :param messages: The `messages` parameter is a list of `Message` objects. It represents the messages
+    exchanged between the user and the chatbot. Each `Message` object typically contains information
+    such as the text of the message, the sender, the timestamp, etc
+    :type messages: List[Message]
+    :param state: The `state` parameter is a dictionary that stores the state of the conversation. It
+    can be used to store information or context that needs to be maintained across multiple requests or
+    messages in the conversation. The `state` parameter is optional and can be set to `None` if not
+    needed
+    :type state: dict
+    :return: a list of `Message` objects.
+    """
+    file_path = os.environ.get("FILE_PATH", None)
+    logging.info(file_path)
+    if not file_path:
+        return []
+
+    module = get_module_from_file_path(file_path)
+
+    print("here", state)
+
+    # Call the on_message function from the dynamically loaded module
+    response = module.on_message(messages, state)
+    if type(response) is tuple:
+        bot_response, new_state = response
+        return {
+            "botResponse": {"content": bot_response, "role": "assistant"},
+            "newState": new_state,
+        }
+    elif type(response) is str:
+        return {"botResponse": {"content": response, "role": "assistant"}}
+
+
+# Mount the static directory (frontend files)
+app.mount(
+    "/assets",
+    StaticFiles(directory="textbase/frontend/dist/assets", html=True),
+    name="static",
+)

pyproject.toml

@@ -0,0 +1,34 @@
+import os
+import zipfile
+import requests
+
+def download_and_extract_zip(zip_url, destination_folder):
+    """
+    The function `download_and_extract_zip` downloads a zip file from a given URL and extracts its
+    contents to a specified destination folder.
+    
+    :param zip_url: The URL of the zip file that you want to download and extract
+    :param destination_folder: The destination_folder parameter is the path where you want to save the
+    downloaded zip file and extract its contents. It can be an absolute path or a relative path to the
+    current working directory
+    """
+    # Create the destination folder if it doesn't exist
+    os.makedirs(destination_folder, exist_ok=True)
+
+    # Download the zip file
+    response = requests.get(zip_url)
+    if response.status_code == 200:
+        zip_file_path = os.path.join(destination_folder, "frontend.zip")
+        with open(zip_file_path, 'wb') as f:
+            f.write(response.content)
+
+        # Extract the contents of the zip file
+        with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+            zip_ref.extractall(destination_folder)
+
+        # Remove the zip file after extraction
+        os.remove(zip_file_path)
+
+        print("Zip file downloaded and extracted successfully.")
+    else:
+        print("Failed to download the zip file.")

tests/__init__.py

@@ -0,0 +1,18 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.cjs'],
+  parser: '@typescript-eslint/parser',
+  plugins: ['react-refresh'],
+  rules: {
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}

textbase/__init__.py

@@ -0,0 +1,23 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

textbase/__pycache__/__init__.cpython-311.pyc

@@ -0,0 +1,27 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
+
+- Configure the top-level `parserOptions` property like this:
+
+```js
+   parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+    project: ['./tsconfig.json', './tsconfig.node.json'],
+    tsconfigRootDir: __dirname,
+   },
+```
+
+- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
+- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
+- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list