first commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/push-hf.yml

@@ -0,0 +1,85 @@
+name: Push to HuggingFace Spaces
+on:
+  push:
+    branches:
+      - release/*
+      - main
+
+env:
+    IMAGE_NAME: ${{ github.repository }}
+    IMAGE_TAG: ${{ github.sha }}
+    VERSION: latest
+    HF_TOKEN: ${{ secrets.HF_TOKEN }}
+    HF_ORGANIZATION: ${{ vars.HF_ORGANIZATION }}
+    HF_SPACE: ${{ vars.HF_SPACE }}
+
+jobs:
+  push-to-hf:
+    runs-on: ubuntu-latest
+    steps:
+      # checkout the repository
+      - name: Checkout the repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          lfs: true
+      
+      # - name: setup git lfs
+      #   run: |
+      #     git lfs install
+      #     git lfs track "*.csv"
+      #     git add .gitattributes
+      #     git commit -m "Add .gitattributes"
+
+      # - name: Configure Git LFS for large files
+      #   run: |
+      #     find . -name "*.csv" -type f -size +10M | while read file; do
+      #       git lfs track "$file"
+      #       git add "$file"
+      #     done
+      
+      # print environment variables
+      - name: Print environment variables
+        run: |
+          echo "IMAGE_NAME: $IMAGE_NAME"
+          echo "IMAGE_TAG: $IMAGE_TAG"
+          echo "VERSION: $VERSION"
+          echo HF_TOKEN: $HF_TOKEN
+          echo HF_ORGANIZATION: $HF_ORGANIZATION
+          echo HF_SPACE: $HF_SPACE
+
+      # extract version from branch name and set it as an environment variable when release branch is pushed
+      - name: Extract version from branch name
+        if: startsWith(github.ref, 'refs/heads/release/')
+        id: extract_version
+        run: |
+          echo "IMAGE_TAG=${GITHUB_REF#refs/heads/release/}" >> $GITHUB_ENV
+
+      # print version
+      - name: Print version
+        id: print_version
+        run: |
+          echo "VERSION: $VERSION"
+
+      # build the docker image and push ghcr.io
+      - name: Build and push the docker image
+        if: startsWith(github.ref, 'refs/heads/release/')
+        run: |
+          docker build -t $IMAGE_NAME:$IMAGE_TAG .
+          docker tag $IMAGE_NAME:$IMAGE_TAG ghcr.io/$IMAGE_NAME:latest
+
+          docker push ghcr.io/$IMAGE_NAME:$IMAGE_TAG
+          docker push ghcr.io/$IMAGE_NAME:latest
+
+      # push to HuggingFace Spaces when branch name is main
+      - name: Push to HF Space
+        if: startsWith(github.ref, 'refs/heads/main')
+        run: |
+          git config --global user.email "actions@github.com"
+          git config --global user.name "GitHub Actions"
+          git remote add hf "https://api:$HF_TOKEN@huggingface.co/spaces/$HF_ORGANIZATION/$HF_SPACE"
+          git fetch hf
+          git push hf main --force
+
+
+

.gitignore

@@ -0,0 +1,3 @@
+.venv
+.idea
+__pycache__

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.12-slim
+
+RUN useradd -m -u 1000 chameleon
+
+USER chameleon
+
+ENV PATH="/home/chameleon/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=chameleon requirements.txt requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=chameleon . .
+
+# HuggingFace Space port
+ENV PORT=7860
+
+# Expose the port
+EXPOSE 7860
+
+# Start command for loop
+CMD ["sh", "-c", "python bot_telegram.py & tail -f /dev/null"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Telegram Bot
+emoji: 🔥
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+short_description: it is making not accessible for other people
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,7 @@
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/")
+def greet_json():
+    return {"Hello": "World!"}

bot_telegram.py

@@ -0,0 +1,261 @@
+import os
+import logging
+import asyncio
+import requests
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
+import aiohttp
+import io
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+# Load environment variables from Hugging Face Secrets
+BOT_TOKEN = os.getenv("BOT_TOKEN")
+BASE_URL = os.getenv("BASE_URL")
+HF_TOKEN = os.getenv("HF_TOKEN")
+API_USERNAME = os.getenv("API_USERNAME")
+API_PASSWORD = os.getenv("API_PASSWORD")
+
+# Set the secret password for authentication
+SECRET_PASSWORD = "secure123"  # Change this to your desired password
+
+# Dictionary to store authenticated users
+AUTHENTICATED_USERS = set()
+AWAITING_PASSWORD = set()
+
+
+class TelegramBot:
+    """A Telegram bot with password-based authentication."""
+
+    def __init__(self, bot_token, base_url, username, password):
+        """Initialize the bot with Telegram API token, API credentials, and authentication."""
+        self.bot_token = bot_token
+        self.base_url = base_url
+        # self.username = username
+        # self.password = password
+        # self.auth_token = None
+
+        # API Endpoints
+        self.login_url = f"{self.base_url}/api/v1/auth/login"
+        self.ai_url = f"{self.base_url}/api/v1/questions/text"
+        self.excel_url = f"{self.base_url}/api/v1/questions/excel"
+
+        # Start Telegram Bot
+        self.app = Application.builder().token(self.bot_token).build()
+        self.setup_handlers()
+
+        # Authenticate with API
+        logging.info("Authenticating with API...")
+        # self.authenticate()
+
+    # def authenticate(self):
+    #     """Authenticate with the API and retrieve an access token."""
+    #     payload = {"username": self.username, "password": self.password}
+    #     headers = {"Content-Type": "application/json", "accept": "application/json"}
+    #
+    #     try:
+    #         response = requests.post(self.login_url, headers=headers, json=payload)
+    #
+    #         if response.status_code == 200:
+    #             self.auth_token = response.json().get("access_token")
+    #             logging.info("Successfully authenticated with API")
+    #         else:
+    #             logging.error(f"Authentication failed: {response.status_code} - {response.text}")
+    #
+    #     except Exception as e:
+    #         logging.error(f"Authentication Error: {e}")
+
+    async def start_command(self, update: Update, context: CallbackContext):
+        """Handles the /start command and asks for a password if the user is not authenticated."""
+        user_id = update.message.from_user.id
+
+        if user_id in AUTHENTICATED_USERS:
+            await update.message.reply_text(
+                "✅ You are already authenticated!\n\n"
+                "You can:\n"
+                "1. Send me any question as text\n"
+                "2. Send me an Excel file with questions (must have a 'question' column in 'rfp' sheet)\n\n"
+                "Note: Excel files must contain no more than 50 questions."
+            )
+        else:
+            AWAITING_PASSWORD.add(user_id)
+            await update.message.reply_text("🔑 Please enter the secret password to access the bot.")
+
+    async def handle_message(self, update: Update, context: CallbackContext):
+        """Handles all incoming messages."""
+        user_id = update.message.from_user.id
+        user_message = update.message.text.strip()
+
+        # If user is waiting to enter a password, validate it
+        if user_id in AWAITING_PASSWORD:
+            await self.check_password(update, context)
+            return
+
+        # If user is authenticated, process AI request
+        if user_id in AUTHENTICATED_USERS:
+            await self.chat_with_ai(update, context)
+        else:
+            await update.message.reply_text("❌ You are not authenticated. Please enter the password first.")
+
+    async def check_password(self, update: Update, context: CallbackContext):
+        """Checks if the password is correct and authenticates the user."""
+        user_id = update.message.from_user.id
+        user_message = update.message.text.strip()
+
+        if user_message == SECRET_PASSWORD:
+            AUTHENTICATED_USERS.add(user_id)
+            AWAITING_PASSWORD.discard(user_id)
+            logging.info(f"User {user_id} authenticated successfully.")
+            await update.message.reply_text(
+                "✅ Authentication successful!\n\n"
+                "You can:\n"
+                "1. Send me any question as text\n"
+                "2. Send me an Excel file with questions (must have a 'question' column in 'rfp' sheet)\n\n"
+                "Note: Excel files must contain no more than 50 questions."
+            )
+        else:
+            await update.message.reply_text("❌ Wrong password. Try again.")
+
+    async def chat_with_ai(self, update: Update, context: CallbackContext):
+        """Handles messages and sends them to the AI API."""
+        user_id = update.message.from_user.id
+
+        if user_id not in AUTHENTICATED_USERS:
+            await update.message.reply_text("❌ You are not authenticated. Please enter the password first.")
+            return
+
+        # if not self.auth_token:
+        #     self.authenticate()
+        #
+        # if not self.auth_token:
+        #     await update.message.reply_text("Authentication failed. Please try again later.")
+        #     return
+
+        user_message = update.message.text
+
+        hf_authorization = "Bearer " + HF_TOKEN
+        headers = {
+            "Authorization": hf_authorization,
+            "accept": "application/json"
+        }
+
+
+        json_payload = {"question": user_message}
+        form_payload = {"question": user_message}
+
+        try:
+            logging.info(f"Sending payload as JSON: {json_payload}")
+            response = requests.post(self.ai_url, headers={**headers, "Content-Type": "application/json"}, json=json_payload)
+
+            if response.status_code == 422:
+                logging.warning("JSON format rejected. Retrying with form-data...")
+                response = requests.post(self.ai_url, headers={**headers, "Content-Type": "application/x-www-form-urlencoded"},
+                                         data=form_payload)
+
+            if response.status_code == 200:
+                bot_reply = response.json().get("answer", "I didn't understand that.")
+            elif response.status_code == 401:
+                logging.warning("Authorization expired. Re-authenticating...")
+                # self.authenticate()
+                await self.chat_with_ai(update, context)
+                return
+            else:
+                logging.error(f"Error: {response.status_code}")
+                bot_reply = f"Error: {response.status_code}"
+
+        except Exception as e:
+            logging.error(f"Connection error: {e}")
+            bot_reply = f"Connection error: {e}"
+
+        await update.message.reply_text(bot_reply)
+
+    async def handle_excel(self, update: Update, context: CallbackContext):
+        """Handles Excel file uploads."""
+        user_id = update.message.from_user.id
+
+        if user_id not in AUTHENTICATED_USERS:
+            await update.message.reply_text("❌ You are not authenticated. Please enter the password first.")
+            return
+
+        # if not self.auth_token:
+        #     self.authenticate()
+        # 
+        # if not self.auth_token:
+        #     await update.message.reply_text("Authentication failed. Please try again later.")
+        #     return
+
+        document = update.message.document
+        if not document.file_name.endswith(('.xls', '.xlsx')):
+            await update.message.reply_text("Please send only Excel files (.xls or .xlsx)")
+            return
+
+        try:
+            # Send initial processing message
+            processing_msg = await update.message.reply_text("📊 Processing your Excel file... This may take a few minutes.")
+
+            # Get file from Telegram
+            file = await context.bot.get_file(document.file_id)
+            file_bytes = await file.download_as_bytearray()
+
+            headers = {
+                "Authorization": f"Bearer {HF_TOKEN}",
+                "accept": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            }
+
+            async with aiohttp.ClientSession() as session:
+                # Create form data with the file
+                form_data = aiohttp.FormData()
+                form_data.add_field('file',
+                                    file_bytes,
+                                    filename=document.file_name,
+                                    content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+
+                # Send file to API
+                async with session.post(self.excel_url, headers=headers, data=form_data) as response:
+                    if response.status == 200:
+                        # Get the Excel file content directly
+                        file_content = await response.read()
+
+                        # Send the Excel file back to Telegram
+                        await context.bot.send_document(
+                            chat_id=update.effective_chat.id,
+                            document=io.BytesIO(file_content),
+                            filename='rfp_responses.xlsx',
+                            caption="✅ Here's your processed Excel file with answers!"
+                        )
+                        await processing_msg.delete()
+
+                    elif response.status == 401:
+                        logging.warning("Authorization expired. Re-authenticating...")
+                        # self.authenticate()
+                        await self.handle_excel(update, context)
+                    else:
+                        error_text = await response.text()
+                        await processing_msg.edit_text(f"❌ Error processing Excel file: {error_text}")
+
+        except Exception as e:
+            logging.error(f"Error handling Excel file: {e}")
+            await update.message.reply_text(f"❌ Error processing Excel file: {str(e)}")
+
+    def setup_handlers(self):
+        """Set up Telegram command and message handlers."""
+        self.app.add_handler(CommandHandler("start", self.start_command))
+        self.app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message))
+        self.app.add_handler(MessageHandler(filters.Document.FileExtension("xlsx") | filters.Document.FileExtension("xls"), self.handle_excel))
+
+    def run(self):
+        """Start the bot and listen for messages."""
+        logging.info("Starting Telegram bot...")
+        self.app.run_polling()
+
+
+if __name__ == "__main__":
+    bot = TelegramBot(
+        bot_token=BOT_TOKEN,
+        base_url=BASE_URL,
+        username=API_USERNAME,
+        password=API_PASSWORD
+    )
+    bot.run()
+

requirements.txt

@@ -0,0 +1,5 @@
+python-telegram-bot
+requests
+aiohttp
+fastapi
+uvicorn[standard]