Spaces:

Starchik1
/

Chat

Sleeping

App Files Files Community

Starchik1 commited on Nov 6, 2025

Commit

9c8f0a9

verified ·

1 Parent(s): ae79419

Create main.py

Browse files

Files changed (1) hide show

main.py +626 -0

main.py ADDED Viewed

	@@ -0,0 +1,626 @@

+"""
+flask_messenger_single_file.py
+Advanced single-file Flask messenger optimized for mobile (PWA-ready).
+Dependencies:
+    pip install flask flask-socketio
+Optional (better concurrency):
+    pip install eventlet
+Run:
+    python flask_messenger_single_file.py
+"""
+import os
+import uuid
+import sqlite3
+import pathlib
+from datetime import datetime
+from flask import (
+    Flask,
+    request,
+    url_for,
+    send_from_directory,
+    jsonify,
+    render_template_string,
+)
+from flask_socketio import SocketIO, emit, join_room
+# Try to import eventlet for better Socket.IO behavior; fallback allowed
+try:
+    import eventlet  # optional
+    _HAS_EVENTLET = True
+except Exception:
+    _HAS_EVENTLET = False
+# Configuration
+BASE_DIR = pathlib.Path(__file__).parent.resolve()
+UPLOAD_DIR = BASE_DIR / "uploads"
+DB_PATH = BASE_DIR / "chat.db"
+STATIC_DIR = BASE_DIR / "static"
+CHUNK_TEMP = BASE_DIR / "chunk_temp"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(STATIC_DIR, exist_ok=True)
+CHUNK_TEMP.mkdir(exist_ok=True)
+app = Flask(__name__)
+app.config["SECRET_KEY"] = os.environ.get("FLASK_SECRET", "dev_secret_change_me")
+app.config["UPLOAD_FOLDER"] = str(UPLOAD_DIR)
+# Choose async mode
+_async_mode = "eventlet" if _HAS_EVENTLET else "threading"
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode=_async_mode)
+# --- Database helpers ---
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    cur = conn.cursor()
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS messages (
+            id TEXT PRIMARY KEY,
+            username TEXT,
+            avatar TEXT,
+            room TEXT,
+            text TEXT,
+            file_path TEXT,
+            file_name TEXT,
+            mime TEXT,
+            timestamp TEXT,
+            status TEXT
+        )
+        """
+    )
+    conn.commit()
+    conn.close()
+def save_message(msg: dict):
+    conn = sqlite3.connect(DB_PATH)
+    cur = conn.cursor()
+    cur.execute(
+        """INSERT INTO messages (id, username, avatar, room, text, file_path, file_name, mime, timestamp, status)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            msg["id"],
+            msg.get("username"),
+            msg.get("avatar"),
+            msg.get("room"),
+            msg.get("text"),
+            msg.get("file_path"),
+            msg.get("file_name"),
+            msg.get("mime"),
+            msg.get("timestamp"),
+            msg.get("status", "sent"),
+        ),
+    )
+    conn.commit()
+    conn.close()
+def get_recent_messages(room: str, limit: int = 200):
+    conn = sqlite3.connect(DB_PATH)
+    cur = conn.cursor()
+    cur.execute(
+        "SELECT id, username, avatar, text, file_path, file_name, mime, timestamp, status FROM messages WHERE room=? ORDER BY timestamp ASC LIMIT ?",
+        (room, limit),
+    )
+    rows = cur.fetchall()
+    conn.close()
+    out = []
+    for r in rows:
+        out.append(
+            {
+                "id": r[0],
+                "username": r[1],
+                "avatar": r[2],
+                "text": r[3],
+                "file_path": r[4],
+                "file_name": r[5],
+                "mime": r[6],
+                "timestamp": r[7],
+                "status": r[8],
+            }
+        )
+    return out
+init_db()
+# --- UI Template (embedded) ---
+TEMPLATE = r"""
+<!doctype html>
+<html lang="ru">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover" />
+  <title>Mobile Messenger</title>
+  <link rel="manifest" href="/manifest.json">
+  <meta name="theme-color" content="#0d6efd" />
+  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet">
+  <style>
+    :root{--accent:#0d6efd}
+    body{background:#f6f7fb;height:100vh;display:flex;flex-direction:column;margin:0}
+    .app{max-width:900px;margin:0 auto;flex:1;display:flex;flex-direction:column;min-height:0}
+    header{background:linear-gradient(90deg,var(--accent),#0056b3);color:#fff;padding:.9rem}
+    .chat-window{flex:1;overflow:auto;padding:1rem;display:flex;flex-direction:column;gap:.6rem;min-height:0}
+    .msg{max-width:78%;padding:.6rem .8rem;border-radius:12px;box-shadow:0 1px 0 rgba(0,0,0,0.05);word-break:break-word}
+    .from-me{align-self:flex-end;background:#dff3ff}
+    .from-other{align-self:flex-start;background:#fff}
+    .meta{font-size:.75rem;color:#666;margin-bottom:.25rem;display:flex;align-items:center;gap:.5rem}
+    .input-area{padding:.6rem;background:#fff;border-top:1px solid #eee}
+    .attachments{display:flex;gap:.5rem;align-items:center}
+    .file-preview{max-width:160px;border-radius:8px;overflow:hidden}
+    .typing{font-style:italic;color:#666;font-size:.85rem}
+    .avatar{width:36px;height:36px;border-radius:50%;object-fit:cover}
+    .modal{display:none;position:fixed;top:0;left:0;right:0;bottom:0;align-items:center;justify-content:center;background:rgba(0,0,0,0.4)}
+    .modal.show{display:flex}
+    .modal-dialog{max-width:420px;width:100%}
+    @media (max-width:480px){ .msg{max-width:92%} header{padding:.7rem} }
+  </style>
+</head>
+<body>
+  <div class="app shadow-sm d-flex flex-column">
+    <header class="d-flex align-items-center justify-content-between">
+      <div class="d-flex align-items-center gap-2">
+        <img id="roomAvatar" src="" class="avatar" alt="">
+        <div>
+          <div id="roomName">Mobile Chat</div>
+          <div style="font-size:.75rem;opacity:.9">Fast, private, PWA-ready</div>
+        </div>
+      </div>
+      <div>
+        <button id="btnSettings" class="btn btn-sm btn-light">Настройки</button>
+      </div>
+    </header>
+    <div id="chat" class="chat-window" role="log" aria-live="polite"></div>
+    <div class="input-area">
+      <div id="typing" class="typing"></div>
+      <form id="composer" class="d-flex gap-2 align-items-center">
+        <div class="attachments d-flex align-items-center">
+          <label class="btn btn-outline-secondary btn-sm mb-0" title="Прикрепить файл">
+            📎<input id="fileInput" type="file" hidden>
+          </label>
+          <button id="recordBtn" class="btn btn-outline-danger btn-sm mb-0" type="button" title="Записать голос">🔴</button>
+        </div>
+        <input id="message" autocomplete="off" placeholder="Напишите сообщение..." class="form-control form-control-sm" />
+        <button class="btn btn-primary btn-sm" type="submit">Отправить</button>
+      </form>
+    </div>
+  </div>
+  <!-- Settings Modal -->
+  <div class="modal" id="settingsModal" aria-hidden="true">
+    <div class="modal-dialog">
+      <div class="modal-content bg-white rounded p-3">
+        <div class="d-flex justify-content-between align-items-center mb-2">
+          <h5 class="m-0">Настройки</h5>
+          <button id="closeSettings" class="btn btn-sm btn-outline-secondary">✖</button>
+        </div>
+        <div class="mb-2">
+          <label class="form-label">Никнейм</label>
+          <input id="setUsername" class="form-control" />
+        </div>
+        <div class="mb-2">
+          <label class="form-label">URL аватарки (оставьте пустым для генерации)</label>
+          <input id="setAvatar" class="form-control" placeholder="https://..." />
+        </div>
+        <div class="d-flex justify-content-end">
+          <button id="saveSettings" class="btn btn-primary">Сохранить</button>
+        </div>
+      </div>
+    </div>
+  </div>
+<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
+<script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
+<script>
+// Polyfill for getUserMedia in case browser exposes legacy prefixes or lacks navigator.mediaDevices
+if (!navigator.mediaDevices) {
+  navigator.mediaDevices = {};
+}
+if (!navigator.mediaDevices.getUserMedia) {
+  navigator.mediaDevices.getUserMedia = function(constraints) {
+    var getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
+    if (!getUserMedia) {
+      return Promise.reject(new Error('getUserMedia is not implemented in this browser'));
+    }
+    return new Promise(function(resolve, reject) {
+      getUserMedia.call(navigator, constraints, resolve, reject);
+    });
+  }
+}
+// Note: modern browsers block microphone on insecure origins (HTTP over network).
+// For reliable mic access use HTTPS or open page on localhost.
+const socket = io();
+let username = localStorage.getItem('mm_username') || '';
+let avatar = localStorage.getItem('mm_avatar') || '';
+const room = 'global';
+function nano(){return Math.random().toString(36).slice(2,10);}
+if(!username){ username = 'User-'+ nano(); }
+if(!avatar){ avatar = 'https://api.dicebear.com/6.x/thumbs/svg?seed='+encodeURIComponent(username); }
+localStorage.setItem('mm_username', username);
+localStorage.setItem('mm_avatar', avatar);
+document.getElementById('roomAvatar').src = avatar;
+document.getElementById('roomName').innerText = room;
+// Settings modal handlers
+const btnSettings = document.getElementById('btnSettings');
+const settingsModal = document.getElementById('settingsModal');
+const closeSettings = document.getElementById('closeSettings');
+const saveSettings = document.getElementById('saveSettings');
+const setUsername = document.getElementById('setUsername');
+const setAvatar = document.getElementById('setAvatar');
+btnSettings.addEventListener('click', ()=>{
+  setUsername.value = localStorage.getItem('mm_username') || '';
+  setAvatar.value = localStorage.getItem('mm_avatar') || '';
+  settingsModal.classList.add('show');
+  settingsModal.setAttribute('aria-hidden','false');
+});
+closeSettings.addEventListener('click', ()=>{ settingsModal.classList.remove('show'); settingsModal.setAttribute('aria-hidden','true'); });
+saveSettings.addEventListener('click', ()=>{
+  const nu = setUsername.value.trim() || ('User-'+nano());
+  const na = setAvatar.value.trim() || ('https://api.dicebear.com/6.x/thumbs/svg?seed='+encodeURIComponent(nu));
+  username = nu; avatar = na;
+  localStorage.setItem('mm_username', username);
+  localStorage.setItem('mm_avatar', avatar);
+  document.getElementById('roomAvatar').src = avatar;
+  settingsModal.classList.remove('show');
+  settingsModal.setAttribute('aria-hidden','true');
+});
+// load recent messages
+async function loadRecent(){
+  try{
+    const r = await axios.get('/history?room='+encodeURIComponent(room));
+    const list = r.data||[];
+    const chat = document.getElementById('chat');
+    chat.innerHTML='';
+    list.forEach(addMessageToDom);
+    chat.scrollTop = chat.scrollHeight;
+  }catch(e){console.error(e)}
+}
+function safeAvatarFor(msg){
+  return msg.avatar || ('https://api.dicebear.com/6.x/thumbs/svg?seed='+encodeURIComponent(msg.username||'anon'));
+}
+function addMessageToDom(m){
+  const chat = document.getElementById('chat');
+  const el = document.createElement('div');
+  const fromMe = m.username === username;
+  el.className = 'msg '+(fromMe? 'from-me':'from-other');
+  const meta = document.createElement('div'); meta.className='meta';
+  const avatarSrc = safeAvatarFor(m);
+  meta.innerHTML = `<img src="${avatarSrc}" class="avatar"> <strong>${m.username||'Anonymous'}</strong> · <span>${new Date(m.timestamp).toLocaleString()}</span>`;
+  const body = document.createElement('div');
+  if(m.text) {
+    const p = document.createElement('div');
+    p.textContent = m.text;
+    body.appendChild(p);
+  }
+  if(m.file_path){
+    if(m.mime && m.mime.startsWith('image')){
+      const a = document.createElement('a'); a.href = m.file_path; a.target='_blank'; a.className='d-block mt-2';
+      const img = document.createElement('img'); img.src = m.file_path; img.className='file-preview img-fluid';
+      a.appendChild(img);
+      body.appendChild(a);
+    } else if(m.mime && m.mime.startsWith('audio')){
+      const audio = document.createElement('audio'); audio.controls = true; audio.src = m.file_path; audio.className='d-block mt-2';
+      body.appendChild(audio);
+    } else {
+      const a = document.createElement('a'); a.href = m.file_path; a.target='_blank'; a.className='d-block mt-2';
+      a.textContent = '📎 ' + (m.file_name || 'Файл');
+      body.appendChild(a);
+    }
+  }
+  el.appendChild(meta); el.appendChild(body);
+  chat.appendChild(el);
+  chat.scrollTop = chat.scrollHeight;
+}
+socket.on('connect', ()=>{
+  socket.emit('join', {room, username, avatar});
+});
+socket.on('message', (m)=>{ addMessageToDom(m); });
+socket.on('typing', (data)=>{ document.getElementById('typing').innerText = data.username ? data.username + ' печатает...' : ''; });
+// composer
+const composer = document.getElementById('composer');
+const messageInput = document.getElementById('message');
+const fileInput = document.getElementById('fileInput');
+let typingTimer = null;
+messageInput && messageInput.addEventListener('input', ()=>{
+  socket.emit('typing', {room, username});
+  clearTimeout(typingTimer);
+  typingTimer = setTimeout(()=> socket.emit('typing', {room, username: ''}), 1200);
+});
+composer.addEventListener('submit', async (e)=>{
+  e.preventDefault();
+  const text = messageInput.value.trim();
+  if(fileInput.files.length){
+    const file = fileInput.files[0];
+    const fileUrl = await uploadFileChunked(file);
+    socket.emit('post_file_message', {username, avatar, room, text:'', file_path: fileUrl, file_name: file.name, mime: file.type});
+    fileInput.value='';
+  } else if(text){
+    socket.emit('post_message', {username, avatar, room, text});
+    messageInput.value='';
+  }
+});
+// chunked upload (returns file URL)
+async function uploadFileChunked(file){
+  const chunkSize = 1024*256; // 256 KB
+  const total = file.size;
+  let offset = 0; let idx = 0;
+  const fileId = 'f_'+Date.now()+'_'+Math.random().toString(36).slice(2,8);
+  while(offset < total){
+    const chunk = file.slice(offset, offset+chunkSize);
+    const form = new FormData();
+    form.append('chunk', chunk);
+    form.append('file_id', fileId);
+    form.append('index', idx);
+    form.append('total', Math.ceil(total/chunkSize));
+    form.append('file_name', file.name);
+    await axios.post('/upload_chunk', form, { headers: {'Content-Type': 'multipart/form-data'} });
+    offset += chunkSize; idx += 1;
+  }
+  const r = await axios.post('/upload_complete', {file_id:fileId, file_name:file.name});
+  return r.data.url;
+}
+// Blob upload endpoint (for audio messages)
+async function uploadBlob(file){
+  const form = new FormData(); form.append('file', file, file.name || ('blob_'+Date.now()+'.webm'));
+  const r = await axios.post('/upload_blob', form, { headers: {'Content-Type': 'multipart/form-data'} });
+  return r.data.url;
+}
+// Audio recording
+let mediaRecorder = null; let recordedChunks = [];
+const recordBtn = document.getElementById('recordBtn');
+recordBtn.addEventListener('click', async ()=>{
+  if(!mediaRecorder){
+    try{
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      mediaRecorder = new MediaRecorder(stream);
+      mediaRecorder.ondataavailable = (e)=>{ if(e.data && e.data.size) recordedChunks.push(e.data); };
+      mediaRecorder.onstop = async ()=>{
+        const blob = new Blob(recordedChunks, {type: 'audio/webm'});
+        recordedChunks = [];
+        const file = new File([blob], 'voice_'+Date.now()+'.webm', {type: 'audio/webm'});
+        const fileUrl = await uploadBlob(file);
+        socket.emit('post_file_message', {username, avatar, room, text:'', file_path: fileUrl, file_name: file.name, mime: file.type});
+      };
+      mediaRecorder.start();
+      recordBtn.textContent = '⏹️';
+    }catch(err){ alert('Не удалось получить доступ к микрофону: '+err.message); }
+  } else if(mediaRecorder.state === 'recording'){
+    mediaRecorder.stop();
+    mediaRecorder = null; recordBtn.textContent='🔴';
+  }
+});
+// initial load
+loadRecent();
+</script>
+</body>
+</html>
+"""
+# --- Server routes ---
+@app.route("/")
+def index():
+    return render_template_string(TEMPLATE)
+@app.route("/manifest.json")
+def manifest():
+    data = {
+        "name": "Mobile Messenger",
+        "short_name": "Messenger",
+        "start_url": "/",
+        "display": "standalone",
+        "background_color": "#ffffff",
+        "theme_color": "#0d6efd",
+        "icons": [
+            {"src": "/static/icon-192.png", "sizes": "192x192", "type": "image/png"},
+            {"src": "/static/icon-512.png", "sizes": "512x512", "type": "image/png"},
+        ],
+    }
+    return jsonify(data)
+# --- File upload with chunking ---
+@app.route("/upload_chunk", methods=["POST"])
+def upload_chunk():
+    chunk = request.files.get("chunk")
+    file_id = request.form.get("file_id")
+    try:
+        index = int(request.form.get("index", "0"))
+    except Exception:
+        index = 0
+    total = int(request.form.get("total", "1"))
+    file_name = request.form.get("file_name") or "upload"
+    if not chunk or not file_id:
+        return ("Missing chunk or file_id", 400)
+    temp_dir = CHUNK_TEMP / file_id
+    temp_dir.mkdir(parents=True, exist_ok=True)
+    chunk_path = temp_dir / f"{index:06d}.part"
+    chunk.save(str(chunk_path))
+    return ("OK", 200)
+@app.route("/upload_complete", methods=["POST"])
+def upload_complete():
+    data = request.get_json(force=True) if request.is_json else request.form
+    file_id = data.get("file_id")
+    file_name = data.get("file_name") or f"file_{uuid.uuid4().hex}"
+    if not file_id:
+        return ("Missing file_id", 400)
+    temp_dir = CHUNK_TEMP / file_id
+    if not temp_dir.exists():
+        return ("No chunks found", 404)
+    parts = sorted(temp_dir.iterdir())
+    final_name = f"{datetime.utcnow().strftime('%Y%m%d%H%M%S')}_{uuid.uuid4().hex}_{file_name}"
+    final_path = UPLOAD_DIR / final_name
+    with open(final_path, "wb") as wf:
+        for p in parts:
+            with open(p, "rb") as rf:
+                wf.write(rf.read())
+    # cleanup
+    for p in parts:
+        try:
+            p.unlink()
+        except Exception:
+            pass
+    try:
+        temp_dir.rmdir()
+    except Exception:
+        pass
+    url = url_for("uploaded_file", filename=final_name, _external=True)
+    return jsonify({"url": url, "filename": final_name})
+# Direct blob upload (for audio messages and small files)
+@app.route("/upload_blob", methods=["POST"])
+def upload_blob():
+    f = request.files.get("file")
+    if not f:
+        return ("No file", 400)
+    safe_name = f"{datetime.utcnow().strftime('%Y%m%d%H%M%S')}_{uuid.uuid4().hex}_{secure_filename(f.filename)}"
+    path = UPLOAD_DIR / safe_name
+    f.save(str(path))
+    url = url_for("uploaded_file", filename=safe_name, _external=True)
+    return jsonify({"url": url, "filename": safe_name})
+# Serve uploaded files
+@app.route("/uploads/<path:filename>")
+def uploaded_file(filename):
+    return send_from_directory(app.config["UPLOAD_FOLDER"], filename)
+# SocketIO events
+@socketio.on("join")
+def on_join(data):
+    room = data.get("room", "global")
+    join_room(room)
+    system_avatar = "https://api.dicebear.com/6.x/thumbs/svg?seed=System"
+    emit(
+        "message",
+        {
+            "id": str(uuid.uuid4()),
+            "username": "System",
+            "avatar": system_avatar,
+            "text": f"{data.get('username')} присоединился к чату",
+            "timestamp": datetime.utcnow().isoformat(),
+            "room": room,
+        },
+        room=room,
+    )
+@socketio.on("post_message")
+def on_post_message(data):
+    msg = {
+        "id": str(uuid.uuid4()),
+        "username": data.get("username"),
+        "avatar": data.get("avatar"),
+        "room": data.get("room", "global"),
+        "text": data.get("text"),
+        "file_path": None,
+        "file_name": None,
+        "mime": None,
+        "timestamp": datetime.utcnow().isoformat(),
+        "status": "sent",
+    }
+    save_message(msg)
+    emit("message", msg, room=msg["room"])
+@socketio.on("post_file_message")
+def on_post_file_message(data):
+    # Prefer explicit file_path from client
+    file_path = data.get("file_path")
+    file_name = data.get("file_name")
+    mime = data.get("mime")
+    if not file_path and file_name:
+        # try to find file by file_name
+        found = None
+        for f in UPLOAD_DIR.iterdir():
+            if file_name and file_name in f.name:
+                found = f
+                break
+        if found:
+            file_path = url_for("uploaded_file", filename=found.name, _external=True)
+    msg = {
+        "id": str(uuid.uuid4()),
+        "username": data.get("username"),
+        "avatar": data.get("avatar"),
+        "room": data.get("room", "global"),
+        "text": data.get("text", ""),
+        "file_path": file_path,
+        "file_name": file_name,
+        "mime": mime,
+        "timestamp": datetime.utcnow().isoformat(),
+        "status": "sent",
+    }
+    save_message(msg)
+    emit("message", msg, room=msg["room"])
+@socketio.on("typing")
+def on_typing(data):
+    room = data.get("room", "global")
+    emit("typing", {"username": data.get("username")}, room=room, include_self=False)
+# history endpoint
+@app.route("/history")
+def history():
+    room = request.args.get("room", "global")
+    return jsonify(get_recent_messages(room))
+# simple static serve
+@app.route("/static/<path:p>")
+def static_files(p):
+    pth = STATIC_DIR / p
+    if pth.exists():
+        return send_from_directory(str(STATIC_DIR), p)
+    return ("", 404)
+# small helper for safe filenames (to avoid importing heavy libs)
+def secure_filename(name: str) -> str:
+    # very small sanitizer: keep alnum, dot, dash, underscore
+    keep = []
+    for ch in name:
+        if ch.isalnum() or ch in "._-":
+            keep.append(ch)
+    out = "".join(keep)
+    if not out:
+        out = f"file_{uuid.uuid4().hex}"
+    return out
+if __name__ == "__main__":
+    print("Starting Mobile Messenger on http://0.0.0.0:5000")
+    if _HAS_EVENTLET:
+        try:
+            eventlet.monkey_patch()
+        except Exception:
+            pass
+    socketio.run(app, host="0.0.0.0", port=5000)