Update app.py

app.py

@@ -41,10 +41,8 @@ visitor_data_cache = {}
 def download_data_from_hf():
     global visitor_data_cache
     if not HF_TOKEN_READ:
-        logging.warning("HF_TOKEN_READ not set. Skipping Hugging Face download.")
         return False
     try:
-        logging.info(f"Attempting to download {HF_DATA_FILE_PATH} from {REPO_ID}...")
         hf_hub_download(
             repo_id=REPO_ID,
             filename=HF_DATA_FILE_PATH,
@@ -55,20 +53,17 @@ def download_data_from_hf():
             force_download=True,
             etag_timeout=10
         )
-        logging.info("Data file successfully downloaded from Hugging Face.")
         with _data_lock:
             try:
                 with open(DATA_FILE, 'r', encoding='utf-8') as f:
                     visitor_data_cache = json.load(f)
-                logging.info("Successfully loaded downloaded data into cache.")
             except (FileNotFoundError, json.JSONDecodeError) as e:
-                 logging.error(f"Error reading downloaded data file: {e}. Starting with empty cache.")
                  visitor_data_cache = {}
         return True
     except RepositoryNotFoundError:
-        logging.error(f"Hugging Face repository '{REPO_ID}' not found. Cannot download data.")
+        pass
     except Exception as e:
-        logging.error(f"Error downloading data from Hugging Face: {e}")
+        pass
     return False
 
 def load_visitor_data():
@@ -78,15 +73,11 @@ def load_visitor_data():
             try:
                 with open(DATA_FILE, 'r', encoding='utf-8') as f:
                     visitor_data_cache = json.load(f)
-                logging.info("Visitor data loaded from local JSON.")
             except FileNotFoundError:
-                logging.warning(f"{DATA_FILE} not found locally. Starting with empty data.")
                 visitor_data_cache = {}
             except json.JSONDecodeError:
-                logging.error(f"Error decoding {DATA_FILE}. Starting with empty data.")
                 visitor_data_cache = {}
             except Exception as e:
-                logging.error(f"Unexpected error loading visitor data: {e}")
                 visitor_data_cache = {}
         return visitor_data_cache
 
@@ -96,17 +87,14 @@ def save_visitor_data(data):
             visitor_data_cache.update(data)
             with open(DATA_FILE, 'w', encoding='utf-8') as f:
                 json.dump(visitor_data_cache, f, ensure_ascii=False, indent=4)
-            logging.info(f"Visitor data successfully saved to {DATA_FILE}.")
             upload_data_to_hf_async()
         except Exception as e:
-            logging.error(f"Error saving visitor data: {e}")
+            pass
 
 def upload_data_to_hf():
     if not HF_TOKEN_WRITE:
-        logging.warning("HF_TOKEN_WRITE not set. Skipping Hugging Face upload.")
         return
     if not os.path.exists(DATA_FILE):
-        logging.warning(f"{DATA_FILE} does not exist. Skipping upload.")
         return
 
     try:
@@ -114,10 +102,8 @@ def upload_data_to_hf():
         with _data_lock:
              file_content_exists = os.path.getsize(DATA_FILE) > 0
              if not file_content_exists:
-                 logging.warning(f"{DATA_FILE} is empty. Skipping upload.")
                  return
 
-             logging.info(f"Attempting to upload {DATA_FILE} to {REPO_ID}/{HF_DATA_FILE_PATH}...")
              api.upload_file(
                  path_or_fileobj=DATA_FILE,
                  path_in_repo=HF_DATA_FILE_PATH,
@@ -126,9 +112,8 @@ def upload_data_to_hf():
                  token=HF_TOKEN_WRITE,
                  commit_message=f"Update visitor data {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
              )
-        logging.info("Visitor data successfully uploaded to Hugging Face.")
     except Exception as e:
-        logging.error(f"Error uploading data to Hugging Face: {e}")
+        pass
 
 def upload_data_to_hf_async():
      upload_thread = threading.Thread(target=upload_data_to_hf, daemon=True)
@@ -136,11 +121,9 @@ def upload_data_to_hf_async():
 
 def periodic_backup():
      if not HF_TOKEN_WRITE:
-         logging.info("Periodic backup disabled: HF_TOKEN_WRITE not set.")
          return
      while True:
          time.sleep(3600)
-         logging.info("Initiating periodic backup...")
          upload_data_to_hf()
 
 def verify_telegram_data(init_data_str):
@@ -163,13 +146,12 @@ def verify_telegram_data(init_data_str):
             auth_date = int(parsed_data.get('auth_date', [0])[0])
             current_time = int(time.time())
             if current_time - auth_date > 86400:
-                 logging.warning(f"Telegram InitData is older than 1 hour (Auth Date: {auth_date}, Current: {current_time}).")
+                 pass
             return parsed_data, True
         else:
-            logging.warning(f"Data verification failed. Calculated: {calculated_hash}, Received: {received_hash}")
+            pass
             return parsed_data, False
     except Exception as e:
-        logging.error(f"Error verifying Telegram data: {e}")
         return None, False
 
 TEMPLATE = """
@@ -644,7 +626,7 @@ TEMPLATE = """
 
              const modal = document.getElementById("saveModal");
              const saveCardBtn = document.getElementById("save-card-btn");
-             const closeBtn = document(Id("modal-close-btn");
+             const closeBtn = document.getElementById("modal-close-btn");
 
              if (saveCardBtn && modal && closeBtn) {
                  saveCardBtn.addEventListener('click', (e) => {
@@ -902,7 +884,6 @@ dp = Dispatcher()
 
 def generate_bot_response(query: str, context: str):
     if not GEMINI_API_KEY:
-        logging.warning("GEMINI_API_KEY not set. Cannot use AI.")
         return "Извините, функция ответа с использованием AI временно недоступна."
 
     lower_query = query.lower()
@@ -947,7 +928,6 @@ ASSISTANT RESPONSE:"""
         return response.text.strip()
 
     except Exception as e:
-        logging.error(f"Error generating AI response: {e}")
         return "Извините, произошла ошибка при обработке вашего запроса."
 
 @dp.message()
@@ -955,7 +935,6 @@ async def handle_message(message: types.Message):
     logging.info(f"Received message from user {message.from_user.id}: {message.text}")
     user_query = message.text
     if not user_query:
-        logging.warning("Received empty message.")
         return
 
     try:
@@ -974,136 +953,28 @@ async def handle_message(message: types.Message):
         try:
             await message.answer("Извините, произошла внутренняя ошибка при обработке вашего сообщения.")
         except Exception:
-             logging.error("Failed to send error message to user.")
+             pass
 
 
-@app.route('/')
-def index():
-    theme_params = {}
-    return render_template_string(TEMPLATE, theme=theme_params)
-
-@app.route('/verify', methods=['POST'])
-def verify_data():
-    try:
-        req_data = request.get_json()
-        init_data_str = req_data.get('initData')
-        if not init_data_str:
-            return jsonify({"status": "error", "message": "Missing initData"}), 400
-
-        user_data_parsed, is_valid = verify_telegram_data(init_data_str)
-
-        user_info_dict = {}
-        if user_data_parsed and 'user' in user_data_parsed:
-            try:
-                user_json_str = unquote(user_data_parsed['user'][0])
-                user_info_dict = json.loads(user_json_str)
-            except Exception as e:
-                logging.error(f"Could not parse user JSON: {e}")
-                user_info_dict = {}
-
-        if is_valid:
-            user_id = user_info_dict.get('id')
-            if user_id:
-                now = time.time()
-                user_entry = {
-                    str(user_id): {
-                        'id': user_id,
-                        'first_name': user_info_dict.get('first_name'),
-                        'last_name': user_info_dict.get('last_name'),
-                        'username': user_info_dict.get('username'),
-                        'photo_url': user_info_dict.get('photo_url'),
-                        'language_code': user_info_dict.get('language_code'),
-                        'is_premium': user_info_dict.get('is_premium', False),
-                        'phone_number': user_info_dict.get('phone_number'),
-                        'visited_at': now,
-                        'visited_at_str': datetime.fromtimestamp(now).strftime('%Y-%m-%d %H:%M:%S')
-                    }
-                }
-                save_visitor_data(user_entry)
-            return jsonify({"status": "ok", "verified": True, "user": user_info_dict}), 200
-        else:
-            logging.warning(f"Verification failed for user: {user_info_dict.get('id')}")
-            return jsonify({"status": "error", "verified": False, "message": "Invalid data"}), 403
-
-    except Exception as e:
-        logging.exception("Error in /verify endpoint")
-        return jsonify({"status": "error", "message": "Internal server error"}), 500
-
-@app.route('/admin')
-def admin_panel():
-    current_data = load_visitor_data()
-    users_list = list(current_data.values())
-    return render_template_string(ADMIN_TEMPLATE, users=users_list)
-
-@app.route('/admin/download_data', methods=['POST'])
-def admin_trigger_download():
-    success = download_data_from_hf()
-    if success:
-         return jsonify({"status": "ok", "message": "Скачивание данных с Hugging Face завершено. Страница будет обновлена."})
-    else:
-         return jsonify({"status": "error", "message": "Ошибка скачивания данных с Hugging Face. Проверьте логи."}), 500
-
-@app.route('/admin/upload_data', methods=['POST'])
-def admin_trigger_upload():
-    if not HF_TOKEN_WRITE:
-        return jsonify({"status": "error", "message": "HF_TOKEN_WRITE не настроен на сервере."}), 400
-    upload_data_to_hf_async()
-    return jsonify({"status": "ok", "message": "Загрузка данных на Hugging Face запущена в фоновом режиме."})
-
 def start_bot_polling():
-    logging.info("Starting bot polling thread...")
+    logging.info("Starting bot polling thread (signals disabled)...")
     try:
-        asyncio.run(dp.start_polling(bot))
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        loop.run_until_complete(dp.start_polling(bot, handle_signals=False))
         logging.info("Bot polling stopped.")
     except Exception as e:
         logging.exception("Bot polling failed")
 
 if __name__ == '__main__':
-    logging.info("---")
-    logging.info("--- MORSHEN GROUP SERVER (FLASK + AIOGRAM) ---")
-    logging.info("---")
-    logging.info(f"Flask server starting on http://{HOST}:{PORT}")
-    logging.info(f"Using Bot Token ID: {BOT_TOKEN.split(':')[0]}")
-    logging.info(f"Visitor data file: {DATA_FILE}")
-    logging.info(f"Hugging Face Repo: {REPO_ID}")
-    logging.info(f"HF Data Path: {HF_DATA_FILE_PATH}")
-    if not HF_TOKEN_READ or not HF_TOKEN_WRITE:
-         logging.warning("---")
-         logging.warning("--- WARNING: HUGGING FACE TOKEN(S) NOT SET ---")
-         logging.warning("--- Backup/restore functionality will be limited. Set HF_TOKEN_READ and HF_TOKEN_WRITE environment variables.")
-         logging.warning("---")
-    else:
-         logging.info("--- Hugging Face tokens found.")
-         logging.info("--- Attempting initial data download from Hugging Face...")
-         download_data_from_hf()
-
-    if not GEMINI_API_KEY:
-         logging.warning("---")
-         logging.warning("--- WARNING: GEMINI_API_KEY NOT SET ---")
-         logging.warning("--- AI response functionality will be limited or unavailable. Set GEMINI_API_KEY environment variable.")
-         logging.warning("---")
-    else:
-        logging.info("--- GEMINI_API_KEY found.")
-        logging.info(f"--- Using AI model: {GENAI_MODEL}")
-
+    download_data_from_hf()
     load_visitor_data()
 
-    logging.warning("---")
-    logging.warning("--- SECURITY WARNING ---")
-    logging.warning("--- The /admin route and its sub-routes are NOT protected.")
-    logging.warning("--- Implement proper authentication before deploying.")
-    logging.warning("---")
-
     if HF_TOKEN_WRITE:
         backup_thread = threading.Thread(target=periodic_backup, daemon=True)
         backup_thread.start()
-        logging.info("--- Periodic backup thread started (every hour).")
-    else:
-        logging.info("--- Periodic backup disabled (HF_TOKEN_WRITE missing).")
 
     bot_thread = threading.Thread(target=start_bot_polling, daemon=True)
     bot_thread.start()
-    logging.info("--- Telegram bot polling thread initiated.")
 
-    logging.info("--- Server Ready ---")
     app.run(host=HOST, port=PORT, debug=False)