Update app.py

app.py

@@ -259,62 +259,6 @@ async def wirte_file(websocket, key,project_name, path, content, connected):
                 "data": e,
             }
         websockets.broadcast(connected,json.dumps(event))
-        
-    
-
-async def execute_command(websocket, key,project_name, command, connected):
-    base_path = os.path.join(os.getcwd(), 'projects', key,project_name)
-    print(base_path)
-    mod_command = f'cd {base_path}&& {command}'
-
-    try:
-        process = await asyncio.create_subprocess_shell(
-            mod_command,
-            # cwd=base_path,
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            # text=True,
-        )
-
-        async def send_message(message):
-            print('sending msg')
-            # await websocket.send(f'data: {message}')
-            websockets.broadcast(connected,json.dumps(message) )
-
-        # async for line in process.stdout:
-        #     print('sending line')
-            
-        #     event = {
-        #         "type": "terminal-data",
-        #         "data": line.strip().decode('utf-8'),
-        #     }
-        #     await send_message(event)
-            
-
-        # async for line in process.stderr:
-        #     print(f'error:{line.strip()}')
-        #     event = {
-        #         "type": "terminal-error",
-        #         "data": line.strip().decode('utf-8'),
-        #     }
-        #     await send_message(event)
-
-        await asyncio.gather(
-          handle_user_input(websocket, process),
-          read_process_output(process, websocket)
-        )
-
-        return_code = await process.wait()
-        if return_code == 0:
-            # await send_message('Code executed successfully')
-            pass
-        else:
-            # await send_message(f'error:Execution failed with return code {return_code}')
-            pass
-
-    except Exception as e:
-        await error(websocket, str(e))
 
 async def read_process_output(process, websocket):
         async for line in process.stdout:
@@ -520,61 +464,6 @@ async def error(websocket, message):
     await websocket.send(json.dumps(event))
 
 
-async def replay(websocket, game):
-    """
-    Send previous moves.
-
-    """
-    # Make a copy to avoid an exception if game.moves changes while iteration
-    # is in progress. If a move is played while replay is running, moves will
-    # be sent out of order but each move will be sent once and eventually the
-    # UI will be consistent.
-    for player, column, row in game.moves.copy():
-        event = {
-            "type": "play",
-            "player": player,
-            "column": column,
-            "row": row,
-        }
-        await websocket.send(json.dumps(event))
-
-
-async def play(websocket, game, player, connected):
-    """
-    Receive and process moves from a player.
-
-    """
-    async for message in websocket:
-        # Parse a "play" event from the UI.
-        event = json.loads(message)
-        assert event["type"] == "play"
-        column = event["column"]
-
-        try:
-            # Play the move.
-            row = game.play(player, column)
-        except RuntimeError as exc:
-            # Send an "error" event if the move was illegal.
-            await error(websocket, str(exc))
-            continue
-
-        # Send a "play" event to update the UI.
-        event = {
-            "type": "play",
-            "player": player,
-            "column": column,
-            "row": row,
-        }
-        websockets.broadcast(connected, json.dumps(event))
-
-        # If move is winning, send a "win" event.
-        if game.winner is not None:
-            event = {
-                "type": "win",
-                "player": game.winner,
-            }
-            websockets.broadcast(connected, json.dumps(event))
-
 async def exe(websocket,connected,key):
     """
     Receive and process moves from a player.
@@ -760,38 +649,15 @@ async def exe(websocket,connected,key):
             await error(websocket, str(exc))
             continue
 
-        # # Send a "play" event to update the UI.
-        # event = {
-        #     "type": "play",
-        #     "player": player,
-        #     "column": column,
-        #     "row": row,
-        # }
-        # websockets.broadcast(connected, json.dumps(event))
-
-        # # If move is winning, send a "win" event.
-        # if game.winner is not None:
-        #     event = {
-        #         "type": "win",
-        #         "player": game.winner,
-        #     }
-        #     websockets.broadcast(connected, json.dumps(event))
 
 async def start(websocket,events):
-    """
-    Handle a connection from the first player: start a new game.
 
-    """
-    # Initialize a Connect Four game, the set of WebSocket connections
-    # receiving moves from this game, and secret access tokens.
-    game = User()
+    user = User()
     connected = {websocket}
 
     join_key = secrets.token_urlsafe(12)
     JOIN[join_key] = game, connected
 
-    watch_key = secrets.token_urlsafe(12)
-    WATCH[watch_key] = game, connected
 
     try:
         # Send the secret access tokens to the browser of the first player,
@@ -813,7 +679,7 @@ async def start(websocket,events):
         await exe(websocket,connected,join_key)
     finally:
         del JOIN[join_key]
-        del WATCH[watch_key]
+        
 
 
 async def join(websocket, key):
@@ -823,7 +689,7 @@ async def join(websocket, key):
     """
     # Find the Connect Four game.
     try:
-        game, connected = JOIN[key]
+        user, connected = JOIN[key]
     except KeyError:
         await error(websocket, "collabration not found.")
         return
@@ -831,35 +697,6 @@ async def join(websocket, key):
     # Register to receive moves from this game.
     connected.add(websocket)
     try:
-        # base_path = os.path.join(os.getcwd(), 'projects', key,'your_project_name')
-        # mod_command = f'cd {base_path} && ls'
-        # process = await asyncio.create_subprocess_shell(
-        #     mod_command,
-        #     # cwd=base_path,
-        #     stdin=asyncio.subprocess.PIPE,
-        #     stdout=asyncio.subprocess.PIPE,
-        #     stderr=asyncio.subprocess.PIPE,
-        #     # text=True,
-        # )
-        # project_name = []
-        # async for line in process.stdout:
-        #     project_name.append(line.strip().decode('utf-8'))
-
-        # return_code = await process.wait()
-        
-        # current_directory = f'projects/{key}/your_project_name/{project_name[0]}'
-        # print(current_directory)
-        # print("printed")        # Send the first move, in case the first player already played it.
-        # file_structure = await generate_file_structure(current_directory)
-        # # Receive and process moves from the second player.
-        # event = {
-        #     "type": "join",
-        #     "file_structure": json.dumps(file_structure),
-           
-        # }
-        # print('in join')
-        # print(event)
-        # await websocket.send(json.dumps(event))
         event = {
                 "type": "sendDir",
      }
@@ -868,30 +705,6 @@ async def join(websocket, key):
     finally:
         connected.remove(websocket)
 
-
-async def watch(websocket, watch_key):
-    """
-    Handle a connection from a spectator: watch an existing game.
-
-    """
-    # Find the Connect Four game.
-    try:
-        game, connected = WATCH[watch_key]
-    except KeyError:
-        await error(websocket, "Game not found.")
-        return
-
-    # Register to receive moves from this game.
-    connected.add(websocket)
-    try:
-        # Send previous moves, in case the game already started.
-        await replay(websocket, game)
-        # Keep the connection open, but don't receive any messages.
-        await websocket.wait_closed()
-    finally:
-        connected.remove(websocket)
-
-
 async def handler(websocket):
     """
     Handle a connection and dispatch it according to who is connecting.
@@ -907,10 +720,6 @@ async def handler(websocket):
         if "join" in event:
             # Second player joins an existing game.
             await join(websocket, event["join"])
-        elif "watch" in event:
-            # Spectator watches an existing game.
-            await watch(websocket, event["watch"])
-        
         else:
             # First player starts a new game.
             await start(websocket, message)
@@ -919,19 +728,6 @@ async def handler(websocket):
         # Execute a command in the project folder.
         await execute_command(websocket, event["project_name"], event["command"])
 
-    # assert event["type"] == "cmd"
-
-    # if "command" in event:
-    #     # Second player joins an existing game.
-    #     await execute_command(websocket, project_name, event["command"])
-    # elif "watch" in event:
-    #     # Spectator watches an existing game.
-    #     await watch(websocket, event["watch"])
-    # else:
-    #     # First player starts a new game.
-    #     await start(websocket, message)
-
-
 async def main():
     # Set the stop condition when receiving SIGTERM.
     loop = asyncio.get_running_loop()