Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,7 @@
+env
+.dockerignore
+Dockerfile
+Dockerfile.prod
+venv
+.pytest_cache
+.coverage

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"
+

.github/workflows/python-app.yml

@@ -0,0 +1,45 @@
+name: Python application Setup - Chat GPT
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    env:
+      OPEN_AI_KEY: ${{ secrets.OPEN_AI_KEY }}
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.11"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install -r requirements.txt
+        python -m pip install setuptools --upgrade
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        python -m pytest
+    - name : Test with pytest Code Coverage
+      run: |
+        python -m pytest --cov=OpenAI
+    ##- name : Pip audit check
+      ##run: |
+        ##pip-audit
+

.gitignore

@@ -0,0 +1,47 @@
+# JetBrains IDE files
+.idea/
+*.iml
+
+# Compiled files
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.so
+*.dll
+
+# Cache
+.cache/
+
+# Distribution / packaging
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Logs
+logs/
+*.log
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Other
+*.swp
+*.swo
+*.swn
+*.bak
+*.tmp
+*.pyc
+*.pyo
+*.orig
+*.rej
+
+# pytest
+.pytest_cache

Dockerfile

@@ -0,0 +1,42 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-slim
+
+# Checks all images
+ENV DOCKER_CONTENT_TRUST = 1
+
+# Labels
+LABEL version = "1.0.0"
+
+# Set the working directory
+WORKDIR OpenAI
+
+# Create volume directory
+RUN mkdir -p /docker/data
+
+
+# Python should not write bytecode files (.pyc files) to disk.
+ENV PYTHONDONTWRITEBYTECODE 1
+# Disables buffering, allowing the output to be immediately displayed as it is generated.
+ENV PYTHONUNBUFFERED 1
+
+# Installs Nano and Curl
+RUN apt-get update \
+    && apt-get install -y curl \
+    && apt-get -y install  nano \
+     && apt-get clean
+
+# Copy the requirements file into the container
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip3 install --trusted-host pypi.python.org -r requirements.txt
+
+# Set environment variables
+ARG OPEN_AI_KEY
+ENV OPEN_AI_KEY=${OPEN_AI_KEY}
+
+# Copy the rest of the application code
+COPY . .
+
+# Run the command to start the app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "80"]

LICENSE

@@ -0,0 +1,3 @@
+Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License
+
+https://creativecommons.org/licenses/by-nc-nd/4.0/

app.py

@@ -0,0 +1,104 @@
+
+import openai
+import os
+
+from exceptions.GPTException import GPTException
+from models.query_model import QueryModel
+from typing import Optional
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from pathlib import Path
+import logging
+
+app = FastAPI()
+
+# logging
+log = logging.getLogger("uvicorn")
+openai.api_key = os.getenv("OPEN_AI_KEY")
+openai.api_base = os.getenv("BASE_URL") #"https://api.waveai.link/v1"
+
+templates_directory = Path(__file__).parent / "templates"
+templates = Jinja2Templates(directory=templates_directory)
+app.mount("/templates", StaticFiles(directory=templates_directory), name="templates")
+
+
+@app.get("/")
+async def index(request: Request):
+    """
+    Function to return HTML template
+    :param request:
+    :return: HTML template
+    """
+    try:
+        return templates.TemplateResponse("index.html", {"request": request})
+    except HTTPException as exc:
+        log.exception("An HTTPException occurred: %s", exc.detail)
+        return http_exception_handler(exc)
+
+
+@app.post("/ask_gpt4/")
+async def ask_gpt4(query_params: QueryModel, model: Optional[str] = "text-davinci-003") -> dict:
+    """
+    Post Route receive a query and return a response with OpenAIAPI for chat GPT
+    :param query_params: User input in the form of questions to chat GPT
+    :param model: type of model as per OpenAIAPI specifications.
+    :return: Json in the form of a JSONResponse FastAPi instance
+    """
+    try:
+        # Call the OpenAI API
+        # The model used is not gpt4 to use gpt4 as a model a different API has to be used and
+        # in specific the openai.ChatCompletion.create(.....)
+        response = openai.Completion.create(
+            engine=model,
+            prompt=query_params.user_input,
+            max_tokens=1000,
+            n=1,
+            stop=None,
+            temperature=0.5,
+        )
+
+        if len(response.choices) > 0 and hasattr(response.choices[0], "text"):
+            answer = response.choices[0].text.strip()
+            return {"response": answer}
+        else:
+            error_msg = "ChatGPT response does not contain text attribute."
+            log.error(error_msg)
+            raise GPTException(error_msg)
+
+            # return {"error": "ChatGPT response does not contain text attribute."}
+    except GPTException as e:
+        raise e
+    except Exception as e:
+        log.error(f"Exception occurred: {str(e)}")
+        if not query_params.user_input:  # Empty user_input case
+            raise GPTException("Empty user_input", status_code=400)
+        else:
+            raise GPTException(str(e))
+    # except Exception as e:
+    #     return {"error": str(e)}
+
+    # Exception handling
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(exc: HTTPException) -> dict:
+    """
+        Function for exception handling.
+        :param exc: the relevant exception raised
+        :return: dictionary, key , value a pair of status code and error detail.
+        """
+
+    log.debug("Calling http_exception_handler")
+    return {"detail": exc.detail, "status_code": exc.status_code}
+
+
+@app.exception_handler(GPTException)
+async def gpt_exception_handler(request: Request, exc: GPTException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"error": str(exc)},
+    )
+
+

exceptions/GPTException.py

@@ -0,0 +1,7 @@
+class GPTException(Exception):
+    def __init__(self, message, status_code=400):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+

models/query_model.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel, Field
+
+
+class QueryModel(BaseModel):
+    user_input: str = Field(min_length=1, max_length=1000)

requirements.txt

@@ -0,0 +1,72 @@
+aiohttp
+aiosignal
+anyio
+async-timeout
+attrs
+CacheControl
+certifi
+charset-normalizer
+click
+colorama
+coverage
+cyclonedx-python-lib
+dataclasses-json
+defusedxml
+fastapi
+filelock
+flake8
+frozenlist
+greenlet
+h11
+html5lib
+httpcore
+httpx
+idna
+iniconfig
+Jinja2
+langchain
+langchainplus-sdk
+markdown-it-py
+MarkupSafe
+marshmallow
+marshmallow-enum
+mccabe
+mdurl
+msgpack
+multidict
+mypy-extensions
+numexpr
+numpy
+openai
+openapi-schema-pydantic
+packageurl-python
+packaging
+pip-api
+pip-requirements-parser
+pip_audit
+pluggy
+py-serializable
+pycodestyle
+pydantic
+pyflakes
+Pygments
+pyparsing
+pytest
+pytest-cov
+PyYAML
+requests
+rich
+six
+sniffio
+sortedcontainers
+SQLAlchemy
+starlette
+tenacity
+toml
+tqdm
+typing-inspect
+typing_extensions
+urllib3
+uvicorn
+webencodings
+yarl

run.py

@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="127.0.0.1", port=8000, reload=True)

templates/index.html

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Simple Web App to query Chat GPT any question you like</title>
+       <!-- Load Bootstrap CSS -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.0/dist/css/bootstrap.min.css">
+  </head>
+<style>
+ body {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        min-height: 100vh;
+        margin: 0;
+      }
+
+      .container {
+        max-height: 90vh;
+        overflow-y: auto;
+        padding: 1rem;
+      }
+    </style>
+  <body>
+  <div class="container">
+    <h1>Simple Web App to query Chat GPT</h1>
+<form>
+  <label for="question">Enter your question:</label><br>
+  <input type="text" id="question" name="user_input"><br>
+  <br>
+  <button type="button" onclick="sendRequest()">Submit</button>
+</form>
+
+<br>
+<div id="answer">Answer will be shown here</div>
+      </div>
+  </body>
+  <script>
+   async function sendRequest() {
+  const question = document.getElementsByName("user_input")[0].value;
+  const response = await fetch('/ask_gpt4/', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ user_input: question })
+  });
+  const data = await response.json();
+
+  if (response.status === 200) {
+    if ("response" in data) {
+      const answerBox = document.createElement("code");
+      answerBox.style.display = "block";
+      answerBox.style.backgroundColor = "lightgreen";
+      answerBox.style.padding = "10px";
+      answerBox.innerHTML = data.response.replace(/\n/g, "<br>");
+      const answerElement = document.getElementById("answer");
+      while (answerElement.firstChild) {
+        answerElement.removeChild(answerElement.firstChild);
+      }
+      answerElement.appendChild(answerBox);
+    } else if ("error" in data) {
+      document.getElementById("answer").innerHTML = `Error: ${data.error}`;
+    } else {
+      document.getElementById("answer").innerHTML = "Unknown error.";
+    }
+  } else {
+    document.getElementById("answer").innerHTML = "Server error.";
+  }
+}</script>
+</html>

templates/index.js

@@ -0,0 +1,28 @@
+async function sendRequest() {
+  const question = document.getElementsByName("user_input")[0].value;
+  const response = await fetch('/ask_gpt4/', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ user_input: question })
+  });
+  const data = await response.json();
+
+  if (response.status === 200) {
+    if ("response" in data) {
+      const answerBox = document.createElement("code");
+      answerBox.classList.add("d-block", "p-3", "bg-success", "text-white");
+      answerBox.innerHTML = data.response.replace(/\n/g, "<br>");
+      const answerElement = document.getElementById("answer");
+      while (answerElement.firstChild) {
+        answerElement.removeChild(answerElement.firstChild);
+      }
+      answerElement.appendChild(answerBox);
+    } else if ("error" in data) {
+      document.getElementById("answer").innerHTML = `Error: ${data.error}`;
+    } else {
+      document.getElementById("answer").innerHTML = "Unknown error.";
+    }
+  } else {
+    document.getElementById("answer").innerHTML = "Server error.";
+  }
+}

tests/conftest.py

@@ -0,0 +1,26 @@
+# conftest.py
+import os
+import sys
+from fastapi.testclient import TestClient
+import pytest
+from functools import lru_cache
+from fastapi import FastAPI
+import httpx
+
+# Add the path to your source code directory to the system path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Create an instance of FASTAPI to use
+app = FastAPI()
+
+
+@lru_cache()  # Load once by using the lru_cache
+@pytest.fixture(scope="module")
+def test_client() -> TestClient:
+    """
+    Function to create a test client instance to use for testing.
+    Uses a generator to potentially improve performance of a large number of tests.
+    :return: a Test client object.
+    """
+    with TestClient(app) as client:
+        yield client

tests/test_app.py

@@ -0,0 +1,82 @@
+import pytest
+from fastapi.testclient import TestClient
+from fastapi import HTTPException
+from typing import Union, Any
+from app import ask_gpt4, app, http_exception_handler
+from models.query_model import QueryModel
+
+client = TestClient(app)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("query_params, model, expected_output", [
+    (
+            {
+                "user_input": "What is the capital of France?Please answer with one word only and dont add dot at the end"},
+            "text-davinci-003",
+            "Paris"
+    ),
+    (
+            {"user_input": "Which is the capital of UK? Please answer with one word only and dont add dot at the end"},
+            "text-davinci-003",
+            "London"
+    ),
+    # Add more test cases here
+])
+async def test_ask_gpt4(query_params, model, expected_output):
+    response = client.post(
+        "/ask_gpt4/",
+        json={"user_input": query_params["user_input"], "model": model},
+    )
+
+    assert response.status_code == 200
+    json_response = response.json()
+
+    # Check if the response contains a valid answer
+    assert "response" in json_response or "error" in json_response
+
+    # If there's an error, check if it's a known error
+    if "error" in json_response:
+        assert json_response["error"] in [
+            "ChatGPT response does not contain text attribute.",
+            # Add other known errors here
+        ]
+    else:
+        assert json_response["response"] == expected_output
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("status_code, detail, expected_result", [
+    (404, "Not Found", {"detail": "Not Found", "status_code": 404}),
+    (500, "Internal Server Error", {"detail": "Internal Server Error", "status_code": 500}),
+    (401, "Unauthorized", {"detail": "Unauthorized", "status_code": 401}),
+])
+async def test_http_exception_handler(status_code: int, detail: Union[str, dict], expected_result: Any) -> None:
+    """
+    Function to test http exception handler
+    :param status_code: int ,status code e.g. 400, 404 etc.
+    :param detail: str or Dict , detail message
+    :param expected_result:
+    :return: None
+    """
+    exc = HTTPException(status_code=status_code, detail=detail)
+    result = await http_exception_handler(exc)
+    assert result == expected_result
+
+# @pytest.mark.parametrize(
+#     "user_input,expected_status_code",
+#     [
+#         ("What is the capital of France?", 200),
+#         ("", 400),  # Invalid query
+#     ],
+# )
+# def test_ask_gpt4_route(user_input: str, expected_status_code: int):
+#     query = QueryModel(user_input=user_input)
+#     response = client.post("/ask_gpt4/", json=query.dict())
+#
+#     assert response.status_code == expected_status_code
+#
+#     if expected_status_code == 200:
+#         assert "response" in response.json()
+#     else:
+#         assert "error" in response.json()