Update app.py

app.py

@@ -41,8 +41,10 @@ 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,
@@ -53,17 +55,20 @@ 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:
-        pass
+        logging.error(f"Hugging Face repository '{REPO_ID}' not found. Cannot download data.")
     except Exception as e:
-        pass
+        logging.error(f"Error downloading data from Hugging Face: {e}")
     return False
 
 def load_visitor_data():
@@ -73,11 +78,15 @@ 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
 
@@ -87,14 +96,17 @@ 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:
-            pass
+            logging.error(f"Error saving visitor data: {e}")
 
 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:
@@ -102,8 +114,10 @@ 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,
@@ -112,8 +126,9 @@ 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:
-        pass
+        logging.error(f"Error uploading data to Hugging Face: {e}")
 
 def upload_data_to_hf_async():
      upload_thread = threading.Thread(target=upload_data_to_hf, daemon=True)
@@ -121,9 +136,11 @@ 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):
@@ -146,12 +163,13 @@ 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:
-                 pass
+                 logging.warning(f"Telegram InitData is older than 1 hour (Auth Date: {auth_date}, Current: {current_time}).")
             return parsed_data, True
         else:
-            pass
+            logging.warning(f"Data verification failed. Calculated: {calculated_hash}, Received: {received_hash}")
             return parsed_data, False
     except Exception as e:
+        logging.error(f"Error verifying Telegram data: {e}")
         return None, False
 
 TEMPLATE = """
@@ -626,7 +644,7 @@ TEMPLATE = """
 
              const modal = document.getElementById("saveModal");
              const saveCardBtn = document.getElementById("save-card-btn");
-             const closeBtn = document.getElementById("modal-close-btn");
+             const closeBtn = document(Id("modal-close-btn");
 
              if (saveCardBtn && modal && closeBtn) {
                  saveCardBtn.addEventListener('click', (e) => {
@@ -884,6 +902,7 @@ 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()
@@ -928,21 +947,35 @@ ASSISTANT RESPONSE:"""
         return response.text.strip()
 
     except Exception as e:
+        logging.error(f"Error generating AI response: {e}")
         return "Извините, произошла ошибка при обработке вашего запроса."
 
 @dp.message()
 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
 
-    await message.answer("Думаю...")
+    try:
+        await message.answer("Думаю...")
+        logging.info("Sent 'Thinking...' message.")
+
+        context = TEMPLATE
+
+        response_text = generate_bot_response(user_query, context)
 
-    context = TEMPLATE
+        await message.answer(response_text)
+        logging.info(f"Sent AI response to user {message.from_user.id}")
 
-    response_text = generate_bot_response(user_query, context)
+    except Exception as e:
+        logging.exception(f"Error handling message from user {message.from_user.id}")
+        try:
+            await message.answer("Извините, произошла внутренняя ошибка при обработке вашего сообщения.")
+        except Exception:
+             logging.error("Failed to send error message to user.")
 
-    await message.answer(response_text)
 
 @app.route('/')
 def index():
@@ -965,6 +998,7 @@ def verify_data():
                 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:
@@ -988,9 +1022,11 @@ def verify_data():
                 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')
@@ -1015,20 +1051,59 @@ def admin_trigger_upload():
     return jsonify({"status": "ok", "message": "Загрузка данных на Hugging Face запущена в фоновом режиме."})
 
 def start_bot_polling():
+    logging.info("Starting bot polling thread...")
     try:
         asyncio.run(dp.start_polling(bot))
+        logging.info("Bot polling stopped.")
     except Exception as e:
-        pass
+        logging.exception("Bot polling failed")
 
 if __name__ == '__main__':
-    download_data_from_hf()
+    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}")
+
     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)