Update app.py

app.py

@@ -1,169 +1,141 @@
-import asyncio
-import websockets
-import json
 import requests
-import logging
-import gradio as gr
-from datetime import datetime
-
-# Set up logging configuration
-#logging.basicConfig(level=logging.INFO)
-
-# Dictionary to store table information
-table = {}
-
-def send_form(form_data):
-    # URL for Google Form
-    url = "https://docs.google.com/forms/u/0/d/e/1FAIpQLSeDkeewjc5CEZ9ORYJix20rjGWr48WFSBryEqp7D2q5Hsd4PA/formResponse"
-    try:
-        # Send POST request with form data
-        response = requests.post(url, data=form_data)
-        response.raise_for_status()  # Raise exception for HTTP errors
-        #logging.info("Submitted successfully to Google Form.")
-    except requests.exceptions.RequestException as e:
-        logging.error("Failed to submit to Google Form: " + str(e))
-
-def parse_card_values(dtCard):
-    # Parse card values based on modulus 20
-    card_values = []
-    for card in dtCard:
-        value = dtCard[card] % 20
-        if value in [1, 14]:
-            card_values.append(1)
-        elif value in [11, 12, 13]:
-            card_values.append(10)
-        elif value in range(2, 11):
-            card_values.append(value)
-        else:
-            card_values.append("")
-    return {"CardValues": card_values}
-
-def handle_case_25(data):
-    # Extract data from case 25
-    group_id = data['groupID']
-    player_score = data['playerScore']
-    banker_score = data['bankerScore']
-    dt_card = data['dtCard']
-    card_values = parse_card_values(dt_card)["CardValues"]
-
-    # Determine result (Player, Banker, Tie)
-    if player_score == banker_score:
-        result = "T"
-    elif player_score > banker_score:
-        result = "P"
+from bs4 import BeautifulSoup
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import re
+import pypub
+import os
+import time  # Thư viện để tính thời gian
+import gradio as gr  # Thêm thư viện Gradio
+
+# Hàm để phân tích URL và tạo api_url và base_url
+def parse_story_url(story_url):
+    match = re.search(r"https://truyenfull\.tv/([^/]+)-f3\.(\d+)/", story_url)
+    if match:
+        story_name = match.group(1)
+        story_id = match.group(2)
+        api_url = f"https://truyenfull.tv/api/chapters/{story_id}/"
+        base_url = f"https://truyenfull.tv/{story_name}/chuong-"
+        return story_name, story_id, api_url, base_url
     else:
-        result = "B"
-
-    # Retrieve additional info from table
-    if group_id in table:
-        info = table[group_id]
-        game_no = info['gameNo']
-        game_no_round = info['gameNoRound']
-        dealer_name = info['dealerName']
-        group_type = info['groupType']
-    else:
-        game_no = game_no_round = dealer_name = group_type = ""
-
-    # Current timestamp
-    today = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    # Construct form data
-    record_form = {
-        "entry.1910151925": group_id,
-        "entry.345081202": card_values[0],
-        "entry.790265993": card_values[2],
-        "entry.266290562": card_values[4],
-        "entry.1840046760": card_values[1],
-        "entry.2050858893": card_values[3],
-        "entry.1372409472": card_values[5],
-        "entry.211810544": player_score,
-        "entry.2078666320": banker_score,
-        "entry.1824106848": result,
-        "entry.1579231357": group_type,
-        "entry.911826972": game_no,
-        "entry.305589575": game_no_round,
-        "entry.992348569": dealer_name
-    }
-    return record_form
-
-async def send_heartbeat(websocket):
-    # Send a heartbeat message to the WebSocket server
-    heartbeat_message = {"protocol": 999, "data": {}}
-    await websocket.send(json.dumps(heartbeat_message))
-    # Wait for a period of time before sending the next heartbeat
-    await asyncio.sleep(10)  # Send heartbeat every 10 seconds
-
-async def send_login(websocket):
-    # Create a JSON message containing login information
-    login_data = {
-        "protocol": 1,
-        "data": {
-            "sid": "ANONYMOUS-1000759",
-            "dtBetLimitSelectID": {
-                "101": 99101, "102": 99102, "103": 99103, "104": 99104,
-                "105": 99105, "106": 99106, "107": 99107, "108": 99108,
-                "110": 99110, "111": 99111, "112": 99112, "113": 99113,
-                "125": 99125, "126": 99126, "128": 99128, "129": 99129
-            },
-            "bGroupList": False,
-            "videoName": "HttpFlv",
-            "videoDelay": 3000,
-            "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
-        }
-    }
-    login_message = json.dumps(login_data)
-    # Send the login message to the WebSocket server
-    await websocket.send(login_message)
-
-async def init_sma_ws():
-    uri = "wss://a45gs-t.wmetg.com/15101"
+        raise ValueError("URL không hợp lệ")
+
+# Hàm để lấy thông tin các chương từ API
+def get_chapter_info(api_url):
+    response = requests.get(api_url)
+    response.raise_for_status()  # Ném l��i nếu không thành công
+    data = response.json()
+    return data.get('items', [])
+
+# Hàm để lấy nội dung của một chương dựa trên thứ tự chương
+def get_chapter_content(chapter_index, base_url):
+    chapter_url = base_url + str(chapter_index) + ".html"
     try:
-        async with websockets.connect(uri) as websocket:
-            # Send login message to the WebSocket server
-            await send_login(websocket)
-            logging.info('Login message sent')
-            await send_heartbeat(websocket)
-
-            # Receive and process responses from the server
-            while True:
-                try:
-                    response = await websocket.recv()
-                    json_obj = json.loads(response)
-                    protocol = json_obj["protocol"]
-                    if protocol == 21:
-                        info = json_obj["data"]
-                        group_id = info['groupID']
-                        game_no = info['gameNo']
-                        game_no_round = info['gameNoRound']
-                        dealer_name = info['dealerName']
-                        group_type = info['groupType']
-
-                        table[group_id] = {
-                            'groupType': group_type,
-                            'gameNo': game_no,
-                            'gameNoRound': game_no_round,
-                            'dealerName': dealer_name
-                        }
-
-                    if protocol == 25:
-                        data = handle_case_25(json_obj["data"])
-                        send_form(data)
-                except websockets.exceptions.ConnectionClosedError as e:
-                    logging.error(f"Connection closed: {e}")
-                    break
-    except asyncio.CancelledError:
-        logging.info("WebSocket connection cancelled.")
+        response = requests.get(chapter_url)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+        content_div = soup.find('div', id='chapter-c', class_='chapter-c')
+        return content_div.get_text(separator='\n').strip() if content_div else "Không tìm thấy nội dung chương."
     except Exception as e:
-        logging.error(f"Error: {e}")
+        print(f"Lỗi khi lấy nội dung chương {chapter_index}: {e}")
+        return "Không thể lấy nội dung."
+
+# Hàm để lấy nội dung tất cả các chương và lưu vào file
+def get_all_chapters_content(story_url, start_chapter, max_chapters):
+    story_name, story_id, api_url, base_url = parse_story_url(story_url)
+    
+    chapters = get_chapter_info(api_url)
+    if not chapters:
+        return "Không tìm thấy chương nào."
+
+    # Giới hạn số chương tải xuống
+    chapters_to_load = chapters[start_chapter - 1:start_chapter - 1 + max_chapters]
+    chapter_contents = []  # Danh sách lưu nội dung các chương theo thứ tự
+    total_time = 0  # Biến để tính tổng thời gian thực hiện từng chương
+
+    # Sử dụng ThreadPoolExecutor để lấy nội dung các chương song song
+    with ThreadPoolExecutor(max_workers=10) as executor:
+        future_to_chapter = {executor.submit(get_chapter_content, idx + 1, base_url): idx + 1 for idx in range(len(chapters_to_load))}
+        for future in as_completed(future_to_chapter):
+            chapter_index = future_to_chapter[future]
+            start_time = time.time()  # Bắt đầu đo thời gian cho mỗi chương
+            try:
+                content = future.result()
+                # Lưu nội dung chương vào danh sách theo thứ tự
+                chapter_contents.append((chapter_index, content, chapters[chapter_index - 1]['chapter_name']))  # Thêm tiêu đề chương
+                print(f"Đã lưu chương {chapter_index}")
+            except Exception as e:
+                print(f"Lỗi khi lấy nội dung chương {chapter_index}: {e}")
+            end_time = time.time()  # Kết thúc đo thời gian
+            chapter_time = end_time - start_time
+            total_time += chapter_time  # Cộng dồn thời gian cho mỗi chương
+            print(f"Thời gian tải chương {chapter_index}: {chapter_time:.2f} giây")
+
+    # Tính tổng thời gian và thời gian trung bình cho mỗi chương
+    avg_time_per_chapter = total_time / max_chapters if max_chapters > 0 else 0
+    print(f"Tổng thời gian tải {max_chapters} chương: {total_time:.2f} giây")
+    print(f"Thời gian trung bình cho mỗi chương: {avg_time_per_chapter:.2f} giây")
+
+    # Ghi nội dung các chương vào file theo thứ tự đã lưu
+    chapter_contents.sort(key=lambda x: x[0])  # Sắp xếp theo chỉ số chương
+    output_file = f"{story_name}.txt"
+    with open(output_file, 'w', encoding='utf-8') as f:
+        for chapter_index, content, chapter_title in chapter_contents:
+            chapter_name = f"{chapter_title}"  # Tạo tên chương với tiêu đề
+            f.write(f"{chapter_name}\n\n")
+            f.write(f"{content}\n")
+            f.write("-" * 50 + "\n")
+
+    # Tạo file EPUB từ nội dung đã lưu
+    create_epub_from_chapters(chapter_contents, story_name)
+
+    # Trả về kết quả
+    return f"Đã tải thành công {max_chapters} chương. Tổng thời gian: {total_time:.2f} giây, Thời gian trung bình: {avg_time_per_chapter:.2f} giây. File TXT: {output_file}"
+
+# Hàm để tạo file EPUB từ nội dung các chương
+def create_epub_from_chapters(chapter_contents, story_name):
+    try:
+        # Tạo đối tượng Epub
+        my_epub = pypub.Epub(story_name)
 
-def websocket_interface():
-    asyncio.run(init_sma_ws())
+        # Thêm từng chương vào EPUB
+        for chapter_index, content, chapter_title in chapter_contents:
+            # Tạo chương từ nội dung đã có
+            my_chapter = pypub.create_chapter_from_text(content, chapter_title)
+            my_epub.add_chapter(my_chapter)
 
-iface = gr.Interface(
-    fn=websocket_interface,
-    inputs=None,
-    outputs=gr.Textbox(label="Output"),
-    title="WebSocket Interface"
-)
+        # Lưu file EPUB
+        output_directory = f"./{story_name}.epub"
+        my_epub.create(output_directory)  # Lưu file EPUB
+        print(f"Đã tạo file EPUB: {output_directory}")
 
-iface.launch()
+    except Exception as e:
+        print(f"Lỗi khi tạo file EPUB: {e}")
+
+# Giao diện Gradio
+def gradio_interface(story_url, start_chapter, max_chapters):
+    # Bắt đầu đo thời gian cho toàn bộ quá trình
+    start_total_time = time.time()
+
+    # Gọi hàm tải và xử lý nội dung
+    result = get_all_chapters_content(story_url, int(start_chapter), int(max_chapters))
+
+    # Kết thúc đo thời gian
+    end_total_time = time.time()
+
+    # Tính tổng thời gian cho toàn bộ quá trình
+    total_process_time = end_total_time - start_total_time
+    result += f"\nTổng thời gian hoàn thành tất cả các chức năng: {total_process_time:.2f} giây"
+    return result
+
+# Tạo giao diện với Gradio
+gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Textbox(label="URL Truyện", placeholder="Nhập URL của truyện từ truyenfull.tv"),
+        gr.Textbox(label="Số chương bắt đầu", placeholder="Nhập số chương bắt đầu"),
+        gr.Textbox(label="Số chương muốn tải", placeholder="Nhập số chương muốn tải")
+    ],
+    outputs="text",
+    title="Truyện Full Downloader",
+    description="Công cụ tải truyện từ truyenfull.tv và tạo file EPUB."
+).launch()