project-chip
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎.version_information‎
Lines changed: 1 addition & 1 deletion b/‎.version_information‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎app/api/api_v1/endpoints/test_run_executions.py‎
Lines changed: 75 additions & 22 deletions b/‎app/api/api_v1/endpoints/test_run_executions.py‎
Lines changed: 75 additions & 22 deletions
diff --git a/‎app/api/api_v1/sockets/web_sockets.py‎
Lines changed: 42 additions & 3 deletions b/‎app/api/api_v1/sockets/web_sockets.py‎
Lines changed: 42 additions & 3 deletions
diff --git a/‎app/constants/websockets_constants.py‎
Lines changed: 22 additions & 0 deletions b/‎app/constants/websockets_constants.py‎
Lines changed: 22 additions & 0 deletions
diff --git a/‎app/container_manager/container_manager.py‎
Lines changed: 8 additions & 4 deletions b/‎app/container_manager/container_manager.py‎
Lines changed: 8 additions & 4 deletions
@@ -16,3 +16,4 @@ test_db_creation.lock
 test_collections/matter/sdk_tests/sdk_checkout
 performance-logs
 test_collections/matter/sdk_tests/custom_python_tests_info.json
+test_collections/matter/sdk_tests/python_tests_info.json
@@ -1 +1 @@
-v2.13+summer2025
+v2.14+fall2025
@@ -97,36 +97,92 @@ def create_test_run_execution(
     return test_run_execution
 
 
+def __convert_pics_dict_to_object(pics: dict) -> Optional[schemas.PICS]:
+    """Convert a dictionary to a PICS object.
+
+    Args:
+        pics (dict): Dictionary containing PICS data
+
+    Returns:
+        schemas.PICS: PICS object if conversion successful.
+    """
+    if not pics:
+        return schemas.PICS(clusters={})
+
+    try:
+        return schemas.PICS(**pics)
+    except Exception as e:
+        logger.error(f"Invalid PICS data: {e}")
+        return None
+
+
 @router.post("/cli", response_model=schemas.TestRunExecutionWithChildren)
 def create_cli_test_run_execution(
     *,
     db: Session = Depends(get_db),
     test_run_execution_in: schemas.TestRunExecutionCreate,
     selected_tests: schemas.TestSelection,
-    config: dict = {},
+    config: Optional[dict] = None,
+    pics: dict = {},
 ) -> TestRunExecution:
-    """Creates a new test run execution on CLI request."""
-    if not config:
+    """Creates a new test run execution on CLI request.
+
+    Args:
+        test_run_execution_in: Test run execution data
+        selected_tests: Selected tests to run
+        config: Configuration parameters (optional)
+        pics: PICS configuration (optional)
+    """
+    if config is None:
         config = default_environment_config.__dict__
 
     logger.info(f"CLI Config Arguments: {config}")
+    logger.info(f"CLI PICS Arguments: {pics}")
 
-    # Retrieve the default CLI project
-    cli_project = crud.project.get_by_name(db=db, name=DEFAULT_CLI_PROJECT_NAME)
+    # Convert pics dict to PICS object if provided
+    pics_obj = __convert_pics_dict_to_object(pics)
+    if pics_obj is None:
+        raise HTTPException(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail="Invalid PICS data provided. Please check the format.",
+        )
 
-    # If the default CLI project does not exist, create it
-    if not cli_project:
-        project = schemas.ProjectCreate(name=DEFAULT_CLI_PROJECT_NAME)
-        project.config = config
-        project = crud.project.create(db=db, obj_in=project)
+    # Use provided project_id or default CLI project
+    if test_run_execution_in.project_id is not None:
+        project = crud.project.get(db=db, id=test_run_execution_in.project_id)
+        # Use the specified project_id
+        if not project:
+            raise HTTPException(
+                status_code=HTTPStatus.NOT_FOUND,
+                detail=f"Project with id {test_run_execution_in.project_id} not found.",
+            )
+        project_update = schemas.ProjectUpdate(config=config)
+
+        if pics_obj:
+            project_update.pics = pics_obj
+
+        project = crud.project.update(db=db, db_obj=project, obj_in=project_update)
     else:
-        # Update the default CLI project the cli config argument
-        project = crud.project.update(
-            db=db, db_obj=cli_project, obj_in=schemas.ProjectUpdate(config=config)
-        )
+        # Retrieve the default CLI project
+        cli_project = crud.project.get_by_name(db=db, name=DEFAULT_CLI_PROJECT_NAME)
+
+        # If the default CLI project does not exist, create it
+        if not cli_project:
+            project_create = schemas.ProjectCreate(name=DEFAULT_CLI_PROJECT_NAME)
+            project_create.config = config
+            if pics_obj:
+                project_create.pics = pics_obj
+            project = crud.project.create(db=db, obj_in=project_create)
+        else:
+            # Update the default CLI project with the cli config argument and pics
+            project_update = schemas.ProjectUpdate(config=config)
+            if pics_obj:
+                project_update.pics = pics_obj
+            project = crud.project.update(
+                db=db, db_obj=cli_project, obj_in=project_update
+            )
+        test_run_execution_in.project_id = project.id
 
-    # TODO: Remove test_run_config completely from the project
-    test_run_execution_in.project_id = project.id
     test_run_execution_in.certification_mode = False
 
     test_run_execution = crud.test_run_execution.create(
@@ -152,12 +208,9 @@ def rename_test_run_execution(
     test_run_execution_in = TestRunExecutionUpdate.from_orm(test_run_execution)
     test_run_execution_in.title = new_execution_name.strip()
 
-    try:
-        return crud.test_run_execution.update(
-            db=db, db_obj=test_run_execution, obj_in=test_run_execution_in
-        )
-    except HTTPException:
-        raise
+    return crud.test_run_execution.update(
+        db=db, db_obj=test_run_execution, obj_in=test_run_execution_in
+    )
 
 
 @router.post("/abort-testing", response_model=Dict[str, str])
 
@@ -17,7 +17,9 @@
 
 from fastapi import APIRouter, WebSocket
 from fastapi.websockets import WebSocketDisconnect
+from loguru import logger
 
+from app.constants.websockets_constants import WebSocketConnection, WebSocketTypeEnum
 from app.socket_connection_manager import SocketConnectionManager
 
 router = APIRouter()
@@ -26,18 +28,55 @@
 @router.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket) -> None:
     socket_connection_manager = SocketConnectionManager()
-    await socket_connection_manager.connect(websocket)
+    connection = WebSocketConnection(websocket, WebSocketTypeEnum.MAIN)
+    await socket_connection_manager.connect(connection)
     try:
         while True:
             # WebSocketDisconnect is not raised unless we poll
             # https://github.com/tiangolo/fastapi/issues/3008
             try:
                 message = await asyncio.wait_for(websocket.receive_text(), 0.1)
                 await socket_connection_manager.received_message(
-                    socket=websocket, message=message
+                    websocket=websocket, message=message
                 )
             except asyncio.TimeoutError:
                 pass
 
     except WebSocketDisconnect:
-        socket_connection_manager.disconnect(websocket)
+        socket_connection_manager.disconnect(connection)
+
+
+@router.websocket("/ws/video")
+async def websocket_video_endpoint(websocket: WebSocket) -> None:
+    socket_connection_manager = SocketConnectionManager()
+    connection = WebSocketConnection(websocket, WebSocketTypeEnum.VIDEO)
+    await socket_connection_manager.connect(connection)
+    await socket_connection_manager.relay_video_frames(connection)
+
+
+@router.websocket("/ws/webrtc/controller")
+async def websocket_webrtc_controller_endpoint(websocket: WebSocket) -> None:
+    socket_connection_manager = SocketConnectionManager()
+    connection = WebSocketConnection(websocket, WebSocketTypeEnum.WEBRTC_CONTROLLER)
+    try:
+        if await socket_connection_manager.connect(connection):
+            await socket_connection_manager.start_webrtc_signaling(connection)
+    except Exception as e:
+        logger.error(
+            f"An error occurred during WebRTC Controller WebSocket communication: {e}"
+        )
+        socket_connection_manager.disconnect(connection)
+
+
+@router.websocket("/ws/webrtc/peer")
+async def websocket_webrtc_peer_endpoint(websocket: WebSocket) -> None:
+    socket_connection_manager = SocketConnectionManager()
+    connection = WebSocketConnection(websocket, WebSocketTypeEnum.WEBRTC_PEER)
+    try:
+        if await socket_connection_manager.connect(connection):
+            await socket_connection_manager.start_webrtc_signaling(connection)
+    except Exception as e:
+        logger.error(
+            f"An error occurred during WebRTC Peer WebSocket communication: {e}"
+        )
+        socket_connection_manager.disconnect(connection)
@@ -15,12 +15,17 @@
 #
 from enum import Enum
 
+from fastapi import WebSocket
+
 MESSAGE_ID_KEY = "message_id"
 
 INVALID_JSON_ERROR_STR = "The message received is not a valid JSON object"
 MISSING_TYPE_ERROR_STR = "The message is missing a type key"
 NO_HANDLER_FOR_MSG_ERROR_STR = "There is no handler registered for this message type"
 
+UDP_SOCKET_PORT = 5000
+UDP_SOCKET_INTERFACE = "0.0.0.0"
+
 
 # Enum Keys for different types of messages currently supported by the tool
 class MessageTypeEnum(str, Enum):
@@ -33,6 +38,23 @@ class MessageTypeEnum(str, Enum):
     TIME_OUT_NOTIFICATION = "time_out_notification"
     TEST_LOG_RECORDS = "test_log_records"
     INVALID_MESSAGE = "invalid_message"
+    STREAM_VERIFICATION_REQUEST = "stream_verification_request"
+    IMAGE_VERIFICATION_REQUEST = "image_verification_request"
+    TWO_WAY_TALK_VERIFICATION_REQUEST = "two_way_talk_verification_request"
+    PUSH_AV_STREAM_VERIFICATION_REQUEST = "push_av_stream_verification_request"
+
+
+class WebSocketTypeEnum(str, Enum):
+    MAIN = "main"
+    VIDEO = "video"
+    WEBRTC_PEER = "webrtc_peer"
+    WEBRTC_CONTROLLER = "webrtc_controller"
+
+
+class WebSocketConnection:
+    def __init__(self, websocket: WebSocket, socket_type: WebSocketTypeEnum) -> None:
+        self.websocket = websocket
+        self.type = socket_type
 
 
 # Enum keys used with messages at the top level
 
@@ -146,9 +146,11 @@ def copy_file_from_container(
                 for d in stream:
                     f.write(d)
         except docker.errors.APIError as e:
-            print(f"Error while accessing the Docker API: {e}")
+            logger.error(f"Error while accessing the Docker API: {e}")
+            raise
         except Exception as e:
-            print(f"Unexpected error: {e}")
+            logger.error(f"Unexpected error: {e}")
+            raise
 
     def copy_file_to_container(
         self,
@@ -177,9 +179,11 @@ def copy_file_to_container(
             container.put_archive(f"{destination_container_path.parent}", tar_stream)
 
         except docker.errors.APIError as e:
-            print(f"Error while accessing the Docker API: {e}")
+            logger.error(f"Error while accessing the Docker API: {e}")
+            raise
         except Exception as e:
-            print(f"Unexpected error: {e}")
+            logger.error(f"Unexpected error: {e}")
+            raise
 
 
 container_manager: ContainerManager = ContainerManager()