Added web-flask version so that it's not only Telegram bot

.env.example

@@ -1,3 +0,0 @@
-# .env.example (пушится)
-TELEGRAM_TOKEN=your_telegram_token_here
-HF_API_TOKEN=your_hf_token_here

.gitignore

@@ -1,5 +1,5 @@
 # local models, env files, venv
 .env
-.env.local
 .venv/
-__pycache__/
+__pycache__/
+db/

app.py

@@ -0,0 +1,87 @@
+from flask import Flask, render_template, request
+from modules.db import init_db, save_message, get_recent
+from modules.hf_helpers import hf_infer
+from modules.helpers import detect_lang, MODELS, LABELS, update_history, bar
+
+app = Flask(__name__)
+init_db()
+
+# Optional: color mapping for bars
+COLOR_MAP = {
+    "POSITIVE": "green",
+    "NEGATIVE": "red",
+    "NEUTRAL": "orange",
+    "ПОЗИТИВНЫЙ": "green",
+    "НЕГАТИВНЫЙ": "red",
+    "НЕЙТРАЛЬНЫЙ": "orange",
+    "Emotion": "blue",
+    "Toxicity": "purple"
+}
+
+@app.route("/", methods=["GET", "POST"])
+def index():
+    result = None
+    if request.method == "POST":
+        text = request.form.get("text", "").strip()
+        if text:
+            user_id = 1  # placeholder for single user
+            lang = detect_lang(text)
+            labels = LABELS[lang]
+
+            # --- Sentiment ---
+            sentiment_model = MODELS["ru_sentiment"] if lang == "ru" else MODELS["en_sentiment"]
+            sentiment_data = hf_infer(sentiment_model, text)
+            sentiment_result = None
+            if sentiment_data:
+                top_raw_label = max(sentiment_data, key=lambda x: x["score"])
+                sentiment = labels.get(top_raw_label["label"].lower() if lang == "ru" else top_raw_label["label"], top_raw_label["label"]).upper()
+                score = top_raw_label["score"]
+                sentiment_result = {
+                    "name": sentiment,
+                    "score": int(score * 100),
+                    "bar": bar(score),
+                    "color": COLOR_MAP.get(sentiment, "black")
+                }
+                save_message(user_id, text, sentiment, score)
+
+            pos_count = update_history(user_id, sentiment_result["name"] if sentiment_result else "")
+
+            # --- Emotion (EN only) ---
+            emotion_result = None
+            if lang == "en":
+                emo_data = hf_infer(MODELS["emotion"], text)
+                if emo_data:
+                    top_emo = max(emo_data, key=lambda x: x["score"])
+                    emotion_result = {
+                        "name": top_emo["label"].capitalize(),
+                        "score": int(top_emo["score"]*100),
+                        "bar": bar(top_emo["score"]),
+                        "color": COLOR_MAP["Emotion"]
+                    }
+
+            # --- Toxicity (EN only) ---
+            tox_result = None
+            if lang == "en":
+                tox_data = hf_infer(MODELS["toxicity"], text)
+                if tox_data:
+                    top_tox = max(tox_data, key=lambda x: x["score"])
+                    tox_result = {
+                        "name": top_tox["label"],
+                        "score": int(top_tox["score"]*100),
+                        "bar": bar(top_tox["score"]),
+                        "color": COLOR_MAP["Toxicity"]
+                    }
+
+            result = {
+                "sentiment": sentiment_result,
+                "emotion": emotion_result,
+                "toxicity": tox_result,
+                "pos_count": pos_count
+            }
+
+    history = get_recent(1, 10)
+    return render_template("index.html", result=result, history=history)
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

bot.py

@@ -1,231 +0,0 @@
-import os
-import time
-from collections import deque
-import logging
-import requests
-from dotenv import load_dotenv
-from telegram.ext import ApplicationBuilder, MessageHandler, CommandHandler, filters
-
-from db import init_db, save_message, get_recent
-
-load_dotenv()
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s"
-)
-log = logging.getLogger("sentiment-bot")
-
-TOKEN = os.getenv("TELEGRAM_TOKEN")
-HF_API_TOKEN = os.getenv("HF_API_TOKEN")
-
-# Models
-
-MODELS = {
-    "en_sentiment": "cardiffnlp/twitter-roberta-base-sentiment-latest",
-    "ru_sentiment": "blanchefort/rubert-base-cased-sentiment",
-    "emotion": "j-hartmann/emotion-english-distilroberta-base",
-    "toxicity": "unitary/toxic-bert"
-}
-
-LABELS = {
-    "en": {"LABEL_0": "NEGATIVE", "LABEL_1": "NEUTRAL", "LABEL_2": "POSITIVE"},
-    "ru": {"negative": "НЕГАТИВНЫЙ", "neutral": "НЕЙТРАЛЬНЫЙ", "positive": "ПОЗИТИВНЫЙ"}
-}
-
-USER_HISTORY = {}
-
-# Helper Functions
-
-def detect_lang(text: str) -> str:
-    cyr = sum('а' <= c <= 'я' or 'А' <= c <= 'Я' for c in text)
-    lat = sum('a' <= c <= 'z' or 'A' <= c <= 'Z' for c in text)
-    return "ru" if cyr > lat else "en"
-
-
-def hf_infer(model: str, text: str):
-    try:
-        resp = requests.post(
-            f"https://api-inference.huggingface.co/models/{model}",
-            headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
-            json={"inputs": text},
-            timeout=15
-        )
-        resp.raise_for_status()
-        out = resp.json()
-        if isinstance(out, list) and out:
-            return out
-        return out
-    except Exception as e:
-        log.warning(f"HF inference failed ({model}): {e}")
-        return None
-
-
-def update_history(user_id: int, sentiment: str, max_len=10) -> int:
-    history = USER_HISTORY.setdefault(user_id, deque(maxlen=max_len))
-    history.append((sentiment, time.time()))
-    recent = list(history)[-5:]
-    return sum(s in ("POSITIVE", "ПОЗИТИВНЫЙ") for s, _ in recent)
-
-
-def bar(score: float) -> str:
-    filled = int(score * 10)
-    return "█" * filled + "░" * (10 - filled)
-
-
-# Core Logic
-
-async def analyze(update, context):
-    text = update.message.text.strip()
-    if not text:
-        return
-
-    user_id = update.effective_user.id
-    lang = detect_lang(text)
-
-    # Choose sentiment model
-    sentiment_model = MODELS["ru_sentiment"] if lang == "ru" else MODELS["en_sentiment"]
-    labels = LABELS[lang]
-
-    # HF API call
-    sentiment_data = hf_infer(sentiment_model, text)
-    if not sentiment_data:
-        await update.message.reply_text("⚠️ Couldn't analyze right now, try again.")
-        return
-
-    # Normalize output inline
-    if isinstance(sentiment_data, dict):
-        sentiment_data = [sentiment_data]
-    elif isinstance(sentiment_data, list) and len(sentiment_data) == 1 and isinstance(sentiment_data[0], list):
-        sentiment_data = sentiment_data[0]
-
-    # Filter invalid entries
-    sentiment_data = [item for item in sentiment_data if isinstance(item, dict) and "label" in item and "score" in item]
-
-    if not sentiment_data:
-        await update.message.reply_text("⚠️ Couldn't analyze right now, try again.")
-        return
-
-    
-    top_raw_label = max(sentiment_data, key=lambda x: x["score"])
-    sentiment = labels.get(top_raw_label["label"].lower() if lang == "ru" else top_raw_label["label"], top_raw_label["label"]).upper()
-    score = top_raw_label["score"]
-
-    save_message(user_id, text, sentiment, score)
-    pos_count = update_history(user_id, sentiment)
-
-    lines = []
-
-    if lang == "en":
-        lines.append({
-            "POSITIVE": "😊 Looks positive!",
-            "NEGATIVE": "😞 Sounds negative.",
-            "NEUTRAL": "😐 Neutral tone."
-        }[sentiment])
-        lines.append(f"Sentiment: {sentiment} ({int(score*100)}%) [{bar(score)}]")
-        lines.append(f"Positive in last 5 messages: {pos_count}/5")
-
-        # Emotion
-        emo_data = hf_infer(MODELS["emotion"], text)
-        if isinstance(emo_data, dict):
-            emo_data = [emo_data]
-        elif isinstance(emo_data, list) and len(emo_data) == 1 and isinstance(emo_data[0], list):
-            emo_data = emo_data[0]
-        emo_data = [x for x in emo_data if isinstance(x, dict) and "label" in x and "score" in x]
-        if emo_data:
-            best = max(emo_data, key=lambda x: x["score"])
-            lines.append(f"Emotion: {best['label'].capitalize()}")
-
-        # Toxicity
-        tox_data = hf_infer(MODELS["toxicity"], text)
-        if isinstance(tox_data, dict):
-            tox_data = [tox_data]
-        elif isinstance(tox_data, list) and len(tox_data) == 1 and isinstance(tox_data[0], list):
-            tox_data = tox_data[0]
-        tox_data = [x for x in tox_data if isinstance(x, dict) and "label" in x and "score" in x]
-        if tox_data:
-            t = max(tox_data, key=lambda x: x["score"])
-            lines.append(f"Toxicity: {int(t['score']*100)}% ({t['label']})")
-
-    else:
-        lines.append({
-            "ПОЗИТИВНЫЙ": "😄 Отличный настрой!",
-            "НЕГАТИВНЫЙ": "😞 Похоже на негатив.",
-            "НЕЙТРАЛЬНЫЙ": "😐 Спокойный тон."
-        }[sentiment])
-        lines.append(f"Тональность: {sentiment} ({int(score*100)}%) [{bar(score)}]")
-        lines.append(f"Позитивных за последние 5: {pos_count}/5")
-
-    await update.message.reply_text("\n".join(lines), parse_mode="HTML")
-
-
-# Telegram Bot, User Commands
-
-async def start(update, context):
-    await update.message.reply_text(
-        "👋 Hey! I'm a bot using Hugging Face models.\n"
-        "I analyze your messages for sentiment, emotion, and toxicity.\n"
-        "Russian is supported but with limited features.\n\nUse /info to learn more."
-    )
-
-async def info(update, context):
-    await update.message.reply_text(
-        "ℹ️ <b>Features:</b>\n"
-        "- Sentiment analysis (EN & RU)\n"
-        "- Emotion detection (EN only)\n"
-        "- Toxicity detection (EN only)\n"
-        "- Tracks last messages per user\n"
-        "- Confidence bars & emoji insights\n\n"
-        "Use /credits for model sources or /mystats for your stats.",
-        parse_mode="HTML"
-    )
-
-async def credits(update, context):
-    await update.message.reply_text(
-        "ℹ️ <b>Model Credits:</b>\n"
-        "- <a href='https://huggingface.co/cardiffnlp/twitter-roberta-base-sentiment-latest'>English Sentiment</a>\n"
-        "- <a href='https://huggingface.co/blanchefort/rubert-base-cased-sentiment'>Russian Sentiment</a>\n"
-        "- <a href='https://huggingface.co/j-hartmann/emotion-english-distilroberta-base'>Emotion</a>\n"
-        "- <a href='https://huggingface.co/unitary/toxic-bert'>Toxicity</a>",
-        parse_mode="HTML"
-    )
-
-async def mystats(update, _):
-    user_id = update.effective_user.id
-    history = get_recent(user_id, 50)
-    if not history:
-        await update.message.reply_text("No messages analyzed yet.")
-        return
-
-    sentiments = [s for _, s, _, _ in history]
-    total = len(sentiments)
-    pos = sum(s in ("POSITIVE", "ПОЗИТИВНЫЙ") for s in sentiments)
-    neu = sum(s in ("NEUTRAL", "НЕЙТРАЛЬНЫЙ") for s in sentiments)
-    neg = sum(s in ("NEGATIVE", "НЕГАТИВНЫЙ") for s in sentiments)
-
-    await update.message.reply_text(
-        f"Your stats:\n"
-        f"Positive: {pos} ({pos*100//total}%)\n"
-        f"Neutral: {neu} ({neu*100//total}%)\n"
-        f"Negative: {neg} ({neg*100//total}%)"
-    )
-
-
-# Run Bot
-
-def main():
-    init_db()
-    app = ApplicationBuilder().token(TOKEN).build()
-
-    app.add_handler(CommandHandler("start", start))
-    app.add_handler(CommandHandler("info", info))
-    app.add_handler(CommandHandler("credits", credits))
-    app.add_handler(CommandHandler("mystats", mystats))
-    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, analyze))
-
-    log.info("Bot running...")
-    app.run_polling()
-
-
-if __name__ == "__main__":
-    main()

db.py → modules/db.py

@@ -1,20 +1,20 @@
-# db.py
+import os
 import sqlite3
 import logging
-from typing import Optional, List, Tuple, Dict
+from typing import List, Tuple, Optional
 
 logger = logging.getLogger(__name__)
-DB_PATH = "data.db"
 
-# Module-level cached connection
-_conn: Optional[sqlite3.Connection] = None
+DB_FOLDER = "db"
+os.makedirs(DB_FOLDER, exist_ok=True)
+DB_PATH = os.path.join(DB_FOLDER, "data.db")
 
+_conn: Optional[sqlite3.Connection] = None
 
 def get_db_connection() -> Optional[sqlite3.Connection]:
     global _conn
     if _conn:
         return _conn
-
     try:
         conn = sqlite3.connect(DB_PATH, check_same_thread=False, timeout=20)
         conn.row_factory = sqlite3.Row
@@ -24,47 +24,35 @@ def get_db_connection() -> Optional[sqlite3.Connection]:
         logger.error("Database connection error: %s", e)
         return None
 
-
 def init_db() -> None:
     conn = get_db_connection()
-
     if not conn:
         raise RuntimeError("Could not obtain database connection")
-
     try:
         cur = conn.cursor()
-        # Enable WAL for better concurrency
         cur.execute("PRAGMA journal_mode=WAL")
-        # Create table
-        cur.execute(
-            """
-            CREATE TABLE IF NOT EXISTS history (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id INTEGER NOT NULL,
-                text TEXT NOT NULL,
-                sentiment TEXT NOT NULL,
-                confidence REAL NOT NULL,
-                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-            )
-            """
-        )
-        # Helpful indexes
+        cur.execute("""
+        CREATE TABLE IF NOT EXISTS history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            text TEXT NOT NULL,
+            sentiment TEXT NOT NULL,
+            confidence REAL NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )""")
         cur.execute("CREATE INDEX IF NOT EXISTS idx_user_id ON history(user_id)")
         cur.execute("CREATE INDEX IF NOT EXISTS idx_timestamp ON history(timestamp)")
         cur.execute("CREATE INDEX IF NOT EXISTS idx_user_timestamp ON history(user_id, timestamp)")
         conn.commit()
         logger.info("Database initialized")
-
     except sqlite3.Error as e:
         logger.exception("Database initialization error: %s", e)
         raise
 
-
 def save_message(user_id: int, text: str, sentiment: str, confidence: float) -> bool:
     conn = get_db_connection()
     if not conn:
         return False
-
     try:
         cur = conn.cursor()
         cur.execute(
@@ -72,35 +60,27 @@ def save_message(user_id: int, text: str, sentiment: str, confidence: float) ->
             (user_id, text, sentiment, confidence),
         )
         conn.commit()
-        logger.debug("Saved message for user %s", user_id)
         return True
     except sqlite3.Error as e:
         logger.exception("Error saving message: %s", e)
-        # rollback not strictly necessary after exception, but safe
         try:
             conn.rollback()
         except Exception:
             pass
         return False
 
-
 def get_recent(user_id: int, limit: int = 10) -> List[Tuple]:
     conn = get_db_connection()
     if not conn:
         return []
-
     try:
         cur = conn.cursor()
-        cur.execute(
-            """
-            SELECT text, sentiment, confidence, timestamp
-            FROM history
-            WHERE user_id = ?
-            ORDER BY timestamp DESC
-            LIMIT ?
-            """,
-            (user_id, limit),
-        )
+        cur.execute("""
+        SELECT text, sentiment, confidence, timestamp
+        FROM history
+        WHERE user_id = ?
+        ORDER BY timestamp DESC
+        LIMIT ?""", (user_id, limit))
         rows = cur.fetchall()
         return [tuple(r) for r in rows]
     except sqlite3.Error as e:

modules/helpers.py

@@ -0,0 +1,33 @@
+import time
+from collections import deque
+
+# Models and labels
+MODELS = {
+    "en_sentiment": "cardiffnlp/twitter-roberta-base-sentiment-latest",
+    "ru_sentiment": "blanchefort/rubert-base-cased-sentiment",
+    "emotion": "j-hartmann/emotion-english-distilroberta-base",
+    "toxicity": "unitary/toxic-bert"
+}
+
+LABELS = {
+    "en": {"LABEL_0": "NEGATIVE", "LABEL_1": "NEUTRAL", "LABEL_2": "POSITIVE"},
+    "ru": {"negative": "НЕГАТИВНЫЙ", "neutral": "НЕЙТРАЛЬНЫЙ", "positive": "ПОЗИТИВНЫЙ"}
+}
+
+USER_HISTORY = {}
+
+# Helpers
+def detect_lang(text: str) -> str:
+    cyr = sum('а' <= c <= 'я' or 'А' <= c <= 'Я' for c in text)
+    lat = sum('a' <= c <= 'z' or 'A' <= c <= 'Z' for c in text)
+    return "ru" if cyr > lat else "en"
+
+def update_history(user_id: int, sentiment: str, max_len=10) -> int:
+    history = USER_HISTORY.setdefault(user_id, deque(maxlen=max_len))
+    history.append((sentiment, time.time()))
+    recent = list(history)[-5:]
+    return sum(s in ("POSITIVE", "ПОЗИТИВНЫЙ") for s, _ in recent)
+
+def bar(score: float) -> str:
+    filled = int(score * 10)
+    return "█" * filled + "░" * (10 - filled)

modules/hf_helpers.py

@@ -0,0 +1,30 @@
+import requests
+import logging
+import os
+
+HF_API_TOKEN = os.getenv("HF_API_TOKEN")
+log = logging.getLogger(__name__)
+
+def hf_infer(model: str, text: str):
+    try:
+        resp = requests.post(
+            f"https://api-inference.huggingface.co/models/{model}",
+            headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
+            json={"inputs": text},
+            timeout=15
+        )
+        resp.raise_for_status()
+        out = resp.json()
+
+        # Normalize: dict → list, flatten nested list
+        if isinstance(out, dict):
+            out = [out]
+        elif isinstance(out, list) and len(out) == 1 and isinstance(out[0], list):
+            out = out[0]
+
+        # Filter invalid entries
+        out = [x for x in out if isinstance(x, dict) and "label" in x and "score" in x]
+        return out
+    except Exception as e:
+        log.warning(f"HF inference failed ({model}): {e}")
+        return []

static/style.css

@@ -0,0 +1,74 @@
+body {
+    font-family: sans-serif;
+    background-color: #f4f4f9;
+    margin: 2rem auto;
+    max-width: 800px;
+    color: #333;
+}
+
+h1,
+h2 {
+    text-align: center;
+
+}
+
+form {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    margin-bottom: 2rem;
+}
+
+textarea {
+    width: 100%;
+    max-width: 700px;
+    height: 100px;
+    padding: 0.5rem;
+    border-radius: 6px;
+    border: 1px solid #ccc;
+    resize: vertical;
+}
+
+button {
+    margin-top: 1rem;
+    padding: 0.5rem 1.5rem;
+    border: none;
+    border-radius: 6px;
+    background-color: #4CAF50;
+    color: white;
+    cursor: pointer;
+    transition: 0.2s;
+}
+
+button:hover {
+    background-color: #45a049;
+}
+
+.bar {
+    font-size: 1.2rem;
+    margin: 0.5rem 0;
+}
+
+table {
+    width: 100%;
+    margin-top: 1rem;
+    border-radius: 6px;
+    border-collapse: collapse;
+    background-color: white;
+    box-shadow: 0px 0px 8px rgba(0, 0, 0, 0.1);
+}
+
+th,
+td {
+    border: 1px solid #ddd;
+    padding: 8px;
+    text-align: left;
+}
+
+th {
+    background-color: #f2f2f2;
+}
+
+tr:hover {
+    background-color: #f9f9f9;
+}

templates/index.html

@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Text Analysis</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+</head>
+
+<body>
+
+    <body>
+        <h1>AI Text Analysis</h1>
+        <form method="post">
+            <textarea name="text" placeholder="Type your message...">{{ request.form.text or '' }}</textarea>
+            <button type="submit">Analyze</button>
+        </form>
+
+        {% if result %}
+        <hr>
+        <h2>Result</h2>
+
+        {% if result.sentiment %}
+        <p>Sentiment: <strong>{{ result.sentiment.name }}</strong> ({{ result.sentiment.score }}%)</p>
+        <p class="bar" style="color: {{ result.sentiment.color }}">{{ result.sentiment.bar }}</p>
+        <p>Positive in last 5 messages: {{ result.pos_count }}/5</p>
+        {% endif %}
+
+        {% if result.emotion %}
+        <p>Emotion: <strong>{{ result.emotion.name }}</strong> ({{ result.emotion.score }}%)</p>
+        <p class="bar" style="color: {{ result.emotion.color }}">{{ result.emotion.bar }}</p>
+        {% endif %}
+
+        {% if result.toxicity %}
+        <p>Toxicity: <strong>{{ result.toxicity.name }}</strong> ({{ result.toxicity.score }}%)</p>
+        <p class="bar" style="color: {{ result.toxicity.color }}">{{ result.toxicity.bar }}</p>
+        {% endif %}
+        {% endif %}
+
+
+        {% if history %}
+        <h2>Recent Messages</h2>
+        <table>
+            <tr>
+                <th>Text</th>
+                <th>Sentiment</th>
+                <th>Confidence</th>
+                <th>Timestamp</th>
+            </tr>
+            {% for text, sentiment, confidence, timestamp in history %}
+            <tr>
+                <td>{{ text }}</td>
+                <td>{{ sentiment }}</td>
+                <td>{{ '%.1f' % (confidence*100) }}%</td>
+                <td>{{ timestamp }}</td>
+            </tr>
+            {% endfor %}
+        </table>
+        {% endif %}
+    </body>
+
+</html>