Update app.py

app.py

@@ -2,121 +2,96 @@ import asyncio
 import websockets
 import json
 import requests
-from datetime import datetime
 import logging
+import gradio as gr
+from datetime import datetime
 
 # Set up logging configuration
 logging.basicConfig(level=logging.INFO)
 
-def send(your_data):
-    url = "https://script.google.com/macros/s/AKfycbzT-l3-HhuiXuqUHcEqxAa91DM9WBghdKEaKA4p4wxdN3abuaOvqhX_HhFUEZRj_N92IQ/exec"
+# 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:
-        respond = requests.get(url, data=your_data)
-        respond.raise_for_status()
-        print('response:', respond)
+        # 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 send_form(form_data):
-    url = "https://docs.google.com/forms/u/0/d/e/1FAIpQLSfGlFpSsV9KG40ZT_ttcEFdNl_l2R6FqNDOsXvv8kdTBufVow/formResponse"
 
-    try:
-        respond = requests.post(url, data=form_data)
-        respond.raise_for_status()
-        #print('response:', respond)
-        #logging.info("Submitted successfully to Google Form.")
-    except requests.exceptions.RequestException as e:
-        logging.error("Failed to submit to Google Form: " + str(e))       
-
-def card(dtCard):
-    cardid = []
-    for x in dtCard:
-        if dtCard[x] % 20 in [1, 14]:
-            a = 1
-        elif dtCard[x] % 20 in [11, 12, 13]:
-            a = 10
-        elif dtCard[x] % 20 in [2,3,4,5,6,7,8,9,10]:
-            a = dtCard[x] % 20
+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:
-            a = ""
-        cardid.append(a)
-    return {"Cardid": cardid}
+            card_values.append("")
+    return {"CardValues": card_values}
+
 def handle_case_25(data):
-    groupID = data['groupID']
-    playerScore = data['playerScore']
-    bankerScore = data['bankerScore']
-    dtCard = data['dtCard']
-    cardno = card(dtCard)
-    cardArr = cardno['Cardid']
-    
-    if playerScore == bankerScore:
+    # 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 playerScore > bankerScore:
+    elif player_score > banker_score:
         result = "P"
     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")
-    record = {
-        "Time": today,
-        "ID": groupID,
-        "P1": cardArr[0],
-        "P2": cardArr[2],
-        "P3": cardArr[4],
-        "B1": cardArr[1],
-        "B2": cardArr[3],
-        "B3": cardArr[5],
-        "playerScore": playerScore,
-        "bankerScore": bankerScore,
-        "Result": result,
-    }
-    record_form =  {
-        "entry.1910151925": groupID,
-        "entry.345081202": cardArr[0],
-        "entry.790265993": cardArr[2],
-        "entry.266290562": cardArr[4],
-        "entry.1840046760": cardArr[1],
-        "entry.2050858893": cardArr[3],
-        "entry.1372409472": cardArr[5],
-        "entry.211810544": playerScore,
-        "entry.2078666320": bankerScore,
+
+    # 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 init_sma_ws():
-    uri = "wss://a45gs-t.wmetg.com/15101"
-    try:
-        async with websockets.connect(uri) as websocket:
-            # Send login message to the WebSocket server
-            await send_login(websocket)
-            print('Login message sent')
 
-            # Receive and process responses from the server
-            while True:
-                #await send_heartbeat(websocket)
-                try:
-                    response = await websocket.recv()
-                    #print('Response:', response)
-                    json_obj = json.loads(response)
-                    protocol = json_obj["protocol"]
-                    #print('protocol:', protocol)
-                    #c = json_obj["data"]
-                    #print('data:', json.dumps(c))  
-                    if        protocol==25 :
-                      data=handle_case_25(json_obj["data"])
-                      send_form(data)
-                    # Perform other processing based on the server response
-
-                    # Send periodic heartbeat messages to maintain the connection
-                    #await send_heartbeat(websocket)
-                except websockets.exceptions.ConnectionClosedError as e:
-                    print(f"Connection closed: {e}")
-                    break
-    except asyncio.CancelledError:
-        print("WebSocket connection cancelled.")
-    except Exception as e:
-        print(f"Error: {e}")
+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
@@ -125,22 +100,10 @@ async def send_login(websocket):
         "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
+                "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",
@@ -149,19 +112,58 @@ async def send_login(websocket):
         }
     }
     login_message = json.dumps(login_data)
-
     # Send the login message to the WebSocket server
     await websocket.send(login_message)
 
-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))
+async def init_sma_ws():
+    uri = "wss://a45gs-t.wmetg.com/15101"
+    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)
 
-    # Wait for a period of time before sending the next heartbeat
-    await asyncio.sleep(10)  # Send heartbeat every 10 seconds
+            # 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.")
+    except Exception as e:
+        logging.error(f"Error: {e}")
+
+def websocket_interface():
+    asyncio.run(init_sma_ws())
+
+iface = gr.Interface(
+    fn=websocket_interface,
+    inputs=None,
+    outputs=gr.Textbox(label="Output"),
+    title="WebSocket Interface"
+)
 
-# Create an event loop and run the coroutine until completion
-asyncio.run(init_sma_ws())
-#await init_sma_ws()
-# Run the event loop and execute the asynchronous main function
+iface.launch(debug=True)