Initial commit

.github/workflows/hf-space.yml

@@ -0,0 +1,19 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://mattoofahad:[email protected]/spaces/mattoofahad/whatsapp-endpoint main

.gitignore

@@ -0,0 +1,164 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+ngrok.exe

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11
+
+# Create a user and switch to it
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set the working directory
+WORKDIR /app
+
+# Copy and install dependencies
+COPY --chown=user ./requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir --upgrade -r /app/requirements.txt
+
+# Copy application files
+COPY --chown=user . /app/
+
+# Expose the port
+EXPOSE 7860
+
+# Use CMD or ENTRYPOINT
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,95 @@
+---
+title: This a fastapi endpoint for whatsapp chat.
+colorFrom: red
+colorTo: green
+emoji: 👌👌
+sdk: docker
+app_file: main.py
+pinned: false
+---
+
+# Whatsapp-Chatbot
+A simple repository to integrate a chatbot with whatsapp.
+
+<!-- <p float="left">
+  <img src="" alt="screenshot1" width="300" style="margin-right: 20px;" />
+  <img src="" alt="screenshot2" width="300" />
+</p> -->
+
+<!-- ## Purpose and Features ✨ -->
+
+
+<!-- ## Prerequisites 🔑
+
+To run and deploy the WhatsApp chatbot, you will need the following:
+
+1. [Twilio Account](https://console.twilio.com/user/account-create): Create a Twilio account and obtain your Account SID and Auth Token.
+
+2. WhatsApp Sandbox: Set up a WhatsApp Sandbox in your Twilio account to receive and send messages.
+
+3. Python: Install Python on your local machine. The recommended version is Python 3.x.
+
+4. Ngrok: [Download](https://ngrok.com/download) and install Ngrok from the official website (https://ngrok.com/) based on your operating system.
+
+5. OpenAI API: Sign up for the OpenAI API and obtain your Secret API key from user settings (you may require a paid account for this). -->
+
+## Installation and Usage 🚀💻
+
+1. Create conda env
+    ```bash
+    conda create -n whatsapp_bot_env python=3.10 -y
+    ```
+
+2. Activate env
+    ```bash
+    conda activate whatsapp_bot_env
+    ```
+
+3. Install the required Python packages:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+# docker
+
+## Docker 
+1. Create the docker container
+   ```bash
+   docker build -t whatapp-endpoint .
+   ```
+
+2. run the container
+   ```bash
+   docker run -p 7860:7860 whatapp-endpoint
+   ```
+<!-- 4. Create a `.env` file in the root directory of the project. -->
+
+<!-- 5. Add the following lines to the `.env` file:
+
+   ```plaintext
+   TWILIO_ACCOUNT_SID=your_account_sid
+   TWILIO_AUTH_TOKEN=your_auth_token
+   OPENAI_API_KEY=your_openai_api_key
+   TWILIO_NUMBER= your_twilio_number
+   RECEIPENT_NUMBER= your_number
+   ```
+
+   Replace `your_account_sid`, `your_auth_token`, `your_openai_api_key`, `your_twilio_number`, and `your_number` with your actual credentials. -->
+
+
+5. Run the local server:
+
+   ```bash
+   uvicorn main:app --host 0.0.0.0 --port 5000
+   ```
+
+<!-- 6. Start Ngrok to create a public URL for your local server:
+
+   ```bash
+   ngrok http 5000
+   ```
+
+7. Update the WhatsApp sandbox with the Ngrok URL. Set the incoming message webhook to `<your_ngrok_url>/message` , leave the callback url box empty.
+
+8. Send a message to the WhatsApp sandbox number to interact with the bot and receive information. -->

config.py

@@ -0,0 +1,7 @@
+import os
+
+from dotenv import find_dotenv, load_dotenv
+
+load_dotenv(find_dotenv(), override=True)
+
+LOGGER_LEVEL = os.getenv("LOGGER_LEVEL")

logs.py

@@ -0,0 +1,96 @@
+import asyncio
+import logging
+import sys
+import time
+from functools import wraps
+
+from colorama import Back, Fore, Style, init
+
+from config import LOGGER_LEVEL
+
+# Initialize colorama
+init(autoreset=True)
+
+logger = logging.getLogger(__name__)
+
+if not logger.hasHandlers():
+    logger.propagate = False
+    logger.setLevel(LOGGER_LEVEL)
+
+    # Define color codes for different log levels
+    log_colors = {
+        logging.DEBUG: Fore.CYAN,
+        logging.INFO: Fore.GREEN,
+        logging.WARNING: Fore.YELLOW,
+        logging.ERROR: Fore.RED,
+        logging.CRITICAL: Fore.RED + Back.WHITE + Style.BRIGHT,
+    }
+
+    class ColoredFormatter(logging.Formatter):
+        """Module doc string"""
+
+        def format(self, record):
+            """Module doc string"""
+
+            levelno = record.levelno
+            color = log_colors.get(levelno, "")
+
+            # Format the message
+            message = record.getMessage()
+
+            # Format the rest of the log details
+            details = self._fmt % {
+                "asctime": self.formatTime(record, self.datefmt),
+                "levelname": record.levelname,
+                "module": record.module,
+                "funcName": record.funcName,
+                "lineno": record.lineno,
+            }
+
+            # Combine details and colored message
+            return f"{Fore.WHITE}{details} :: {color}{message}{Style.RESET_ALL}"
+
+    normal_handler = logging.StreamHandler(sys.stdout)
+    normal_handler.setLevel(logging.DEBUG)
+    normal_handler.addFilter(lambda logRecord: logRecord.levelno < logging.WARNING)
+
+    error_handler = logging.StreamHandler(sys.stderr)
+    error_handler.setLevel(logging.WARNING)
+
+    formatter = ColoredFormatter(
+        "%(asctime)s :: %(levelname)s :: %(module)s :: %(funcName)s :: %(lineno)d"
+    )
+
+    normal_handler.setFormatter(formatter)
+    error_handler.setFormatter(formatter)
+
+    logger.addHandler(normal_handler)
+    logger.addHandler(error_handler)
+
+
+def log_execution_time(func):
+    """Module doc string"""
+
+    @wraps(func)
+    def sync_wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        execution_time = end_time - start_time
+        message_string = f"{func.__name__} executed in {execution_time:.4f} seconds"
+        logger.debug(message_string)
+        return result
+
+    @wraps(func)
+    async def async_wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = await func(*args, **kwargs)
+        end_time = time.time()
+        execution_time = end_time - start_time
+        message_string = f"{func.__name__} executed in {execution_time:.4f} seconds"
+        logger.debug(message_string)
+        return result
+
+    if asyncio.iscoroutinefunction(func):
+        return async_wrapper
+    return sync_wrapper

main.py

@@ -0,0 +1,34 @@
+import requests
+from fastapi import FastAPI, Request
+from fastapi.responses import PlainTextResponse
+from pydantic import BaseModel
+
+from logs import logger, log_execution_time
+
+app = FastAPI()
+
+
+class UserInputModel(BaseModel):
+    user_input: str
+
+
+@log_execution_time
+@app.post("/message")
+async def twilio_message_endpoint(request: Request):
+    data = await request.form()
+    user_input = data.get("Body", "")
+    user_input = data.user_input
+    reqUrl = "https://mattoofahad-whatsapp-endpoint.hf.space/message"
+    headersList = {
+        "Accept": "*/*",
+        "User-Agent": "Thunder Client (https://www.thunderclient.com)",
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+    payload = f"Body={user_input}"
+    response = requests.request("POST", reqUrl, data=payload, headers=headersList)
+    logger.info(response.text)
+    return PlainTextResponse(response.text)
+
+
+if __name__ == "__main__":
+    app.run()

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.111.1
+uvicorn==0.30.1
+twilio==8.2.2
+openai==1.40.6
+python-dotenv==1.0.1
+colorama==0.4.6