MEC application.ipynb

    "    except ApiException as e:\n",
    "        logger.error('Exception when calling call_api: %s\\n' % e)\n",
    "    return None\n",
    "    # End of function subscribe_v2x_message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a generic function to delete any MEC service subscription based on the subscription resource URL provided in the Location header of the subscription creation response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def delete_mec_subscription(resource_url: str) -> int:\n",
    "    \"\"\"\n",
    "    Delete any existing MEC subscription\n",
    "    :param resource_url: The subscription URL\n",
    "    :return 0 on success, -1 otherwise\n",
    "    \"\"\"\n",
    "    global MEC_PLTF, logger, service_api\n",
    "\n",
    "    logger.debug('>>> delete_mec_subscription: resource_url: ' + resource_url)\n",
    "    try:\n",
    "        res = urllib3.util.parse_url(resource_url)\n",
    "        if res is None:\n",
    "            logger.error('delete_mec_subscription: Failed to paerse URL')\n",
    "            return -1\n",
    "        header_params = {}\n",
    "        # HTTP header `Accept`\n",
    "        header_params['Accept'] = 'application/json'  # noqa: E501\n",
    "        # HTTP header `Content-Type`\n",
    "        header_params['Content-Type'] = 'application/json'  # noqa: E501\n",
    "        service_api.call_api(res.path, 'DELETE', header_params=header_params, async_req=False)\n",
    "        return 0\n",
    "    except ApiException as e:\n",
    "        logger.error('Exception when calling call_api: %s\\n' % e)\n",
    "    return -1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finaly, here is how to implement the V2X message subscription:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_main():\n",
    "    \"\"\"\n",
    "    This is the second sprint of our skeleton of our MEC application:\n",
    "        - Mec application setup\n",
    "        - Subscribe to V2XMessage\n",
    "        - Delete subscription\n",
    "        - Mec application termination\n",
    "    \"\"\" \n",
    "    global MEC_PLTF, CALLBACK_URI, logger\n",
    "\n",
    "    logger.debug('Starting at ' + time.strftime('%Y%m%d-%H%M%S'))\n",
    "    logger.debug('\\t pwd= ' + os.getcwd())\n",
    "\n",
    "    # Setup the MEC application\n",
    "    (sandbox_name, app_inst_id, sub_id) = mec_app_setup()\n",
    "\n",
    "    # Create a V2X message subscritpion\n",
    "    filter_criteria = V2xMsgSubscriptionFilterCriteria(['1', '2'], 'ETSI')\n",
    "    v2xMsgSubscription = V2xMsgSubscription(callback_reference = CALLBACK_URI + '/vis/v2/v2x_msg_notification', filter_criteria = filter_criteria)\n",
    "    result, status, v2x_sub_id, v2x_resource = subscribe_v2x_message(sandbox_name, v2xMsgSubscription)\n",
    "    if status != 201:\n",
    "        logger.error('Failed to create subscription')\n",
    "\n",
    "    # Any processing here\n",
    "    logger.info('body: ' + str(result.data))\n",
    "    data = json.loads(result.data)\n",
    "    logger.info('data: %s', str(data))\n",
    "    logger.info('app_inst_id: ' + app_inst_id.id)\n",
    "    if sub_id is not None:\n",
    "        logger.info('sub_id: ' + sub_id)\n",
    "    time.sleep(STABLE_TIME_OUT)\n",
    "\n",
    "    # Delete the V2X message subscritpion\n",
    "    delete_mec_subscription(v2x_resource)\n",
    "\n",
    "    # Terminate the MEC application\n",
    "    mec_app_termination(sandbox_name, app_inst_id, sub_id)\n",
    "\n",
    "    logger.debug('Stopped at ' + time.strftime('%Y%m%d-%H%M%S'))\n",
    "    # End of function process_main\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    process_main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notification support\n",
    "\n",
    "To recieve notifcation, our MEC application is required to support an HTTP listenener to recieve POST requests from the MEC Sandbox and reply to them: this is the notification mechanism.\n",
    "\n",
    "This minimalistic HTTP server will also be used to implement the endpoints provided by our MEC application service: see chapter [Our third MEC application: how to create a new MEC Services](#our_third_mec_application_how_to_create_a_new_mec_services).\n",
    "\n",
    "The class HTTPRequestHandler (see cell below) provides the suport of such mechanism.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HTTPServer_RequestHandler(BaseHTTPRequestHandler):\n",
    "    \"\"\"\n",
    "    Minimal implementation of an HTTP server (http only).\n",
    "    \"\"\"\n",
    "\n",
    "    def do_GET(self):\n",
    "        logger.info('>>> do_GET: ' + self.path)\n",
    "\n",
    "        ctype = self.headers.get('content-type')\n",
    "        logger.info('do_GET: ' + ctype)\n",
    "\n",
    "        # Send response status code\n",
    "        self.send_response(HTTPStatus.OK)\n",
    "\n",
    "        # Send message back to client\n",
    "        message = bytes(str(self.headers) + \"\\n\" +self.requestline +\"\\n\", 'utf8')\n",
    "\n",
    "        # Send headers\n",
    "        self.send_header('Content-type','text/plain; charset=utf-8')\n",
    "        self.send_header('Content-length', str(len(message)))\n",
    "        self.end_headers()\n",
    "\n",
    "        # Write content as utf-8 data\n",
    "        self.wfile.write(message)\n",
    "        return\n",
    "\n",
    "    def do_POST(self):\n",
    "        logger.info('>>> do_POST: ' + self.path)\n",
    "\n",
    "        ctype = self.headers.get('content-type')\n",
    "        logger.info('do_POST: ' + ctype)\n",
    "\n",
    "        content_len = int(self.headers.get('Content-Length'))\n",
    "        if content_len != 0:\n",
    "            body = self.rfile.read(content_len).decode('utf8')\n",
    "            logger.info('do_POST: body:' + str(type(body)))\n",
    "            logger.info('do_POST: body:' + str(body))\n",
    "            data = json.loads(str(body))\n",
    "            logger.info('do_POST: data: %s', str(data))\n",
    "\n",
    "        self.send_response(HTTPStatus.NOT_IMPLEMENTED)\n",
    "        self.end_headers()\n",
    "\n",
    "    def do_PUT(self):\n",
    "        logger.info('>>> do_PUT: ' + self.path)\n",
    "\n",
    "        ctype = self.headers.get('content-type')\n",
    "        logger.info('do_PUT: ' + ctype)\n",
    "\n",
    "        self.send_response(HTTPStatus.NOT_IMPLEMENTED)\n",
    "        self.end_headers()\n",
    "\n",
    "    def do_PATCH(self):\n",
    "        logger.info('>>> do_PATCH: ' + self.path)\n",
    "\n",
    "        ctype = self.headers.get('content-type')\n",
    "        logger.info('do_PATCH: ' + ctype)\n",
    "        \n",
    "        self.send_response(HTTPStatus.NOT_IMPLEMENTED)\n",
    "        self.end_headers()\n",
    "    # End of class HTTPRequestHandler\n",
    "\n",
    "    def do_DELETE(self):\n",
    "        logger.info('>>> do_DELETE: ' + self.path)\n",
    "\n",
    "        ctype = self.headers.get('content-type')\n",
    "        logger.info('do_DELETE: ' + ctype)\n",
    "        \n",
    "        self.send_response(HTTPStatus.NOT_IMPLEMENTED)\n",
    "        self.end_headers()\n",
    "    # End of class HTTPRequestHandler\n",
    "\n",
    "def start_notification_server() -> HTTPServer:\n",
    "    \"\"\"\n",
    "    Start the notification server\n",
    "    :return The instance of the HTTP server\n",
    "    \"\"\"\n",
    "    global LISTENER_PORT\n",
    "\n",
    "    server_address = ('', LISTENER_PORT)\n",
    "    httpd = HTTPServer(server_address, HTTPServer_RequestHandler)\n",
    "    # Start notification server in a daemonized thread\n",
    "    notification_server = threading.Thread(target = httpd.serve_forever, name='notification_server')\n",
    "    notification_server.daemon = True\n",
    "    notification_server.start()\n",
    "    return httpd\n",
    "    # End of function HTTPRequestHandler\n",
    "\n",
    "def stop_notification_server(httpd: HTTPServer):\n",
    "    \"\"\"\n",
    "    Stop the notification server\n",
    "    :param The instance of the HTTP server\n",
    "    \"\"\"\n",
    "    httpd.server_close()\n",
    "    httpd=None\n",
    "    # End of function HTTPRequestHandler\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Put all together\n",
    "\n",
    "let's add a subscription the our previous MEC application.\n",
    "The sequence is the following:\n",
    "- Mec application setup\n",
    "- Start the notification server\n",
    "- Get UU unicast provisioning information\n",
    "- Add subscription\n",
    "- Stop the notification server\n",
    "- Mec application termination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_main():\n",
    "    \"\"\"\n",
    "    This is the second sprint of our skeleton of our MEC application:\n",
    "        - Mec application setup\n",
    "        - Start the notification server\n",
    "        - Get UU unicast provisioning information\n",
    "        - Add subscription\n",
    "        - Stop the notification server\n",
    "        - Mec application termination\n",
    "    \"\"\" \n",
    "    global CALLBACK_URI, logger\n",
    "\n",
    "    logger.debug('Starting at ' + time.strftime('%Y%m%d-%H%M%S'))\n",
    "    logger.debug('\\t pwd= ' + os.getcwd())\n",
    "\n",
    "    # Setup the MEC application\n",
    "    (sandbox_name, app_inst_id, sub_id) = mec_app_setup()\n",
    "\n",
    "    # Get UU unicast provisioning information\n",
    "    ecgi = \"268708941961,268711972264\" # List of ecgi spearated by a ','\n",
    "    result = send_uu_unicast_provisioning_info(sandbox_name, ecgi)\n",
    "    if result is None:\n",
    "        logger.error('Failed to get UU unicast provisioning information')\n",
    "    else:\n",
    "        logger.info('UU unicast provisioning information: ' + str(result))\n",
    "\n",
    "    # Start notification server in a daemonized thread\n",
    "    httpd = start_notification_server()\n",
    "\n",
    "    # Create a V2X message subscritpion\n",
    "    filter_criteria = V2xMsgSubscriptionFilterCriteria(['1', '2'], 'ETSI')\n",
    "    v2xMsgSubscription = V2xMsgSubscription(callback_reference = CALLBACK_URI + '/vis/v2/v2x_msg_notification', filter_criteria = filter_criteria)\n",
    "    result, status, v2x_sub_id, v2x_resource = subscribe_v2x_message(sandbox_name, v2xMsgSubscription)\n",
    "    if status != 201:\n",
    "        logger.error('Failed to create subscription')\n",
    "\n",
    "    # Any processing here\n",
    "    logger.info('body: ' + str(result.data))\n",
    "    data = json.loads(result.data)\n",
    "    logger.info('data: %s', str(data))\n",
    "    logger.info('v2x_resource: ' + v2x_resource)\n",
    "    if sub_id is not None:\n",
    "        logger.info('sub_id: ' + sub_id)\n",
    "    time.sleep(STABLE_TIME_OUT)\n",
    "\n",
    "    # Stop notification server\n",
    "    stop_notification_server(httpd)\n",
    "\n",
    "    # Delete the V2X message subscritpion\n",
    "    delete_mec_subscription(v2x_resource)\n",
    "\n",
    "    # Terminate the MEC application\n",
    "    mec_app_termination(sandbox_name, app_inst_id, sub_id)\n",
    "\n",
    "    logger.debug('Stopped at ' + time.strftime('%Y%m%d-%H%M%S'))\n",
    "    # End of function process_main\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    process_main()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create our third MEC application: how to use V2X QoS Prediction\n",
    "\n",
    "The MEC Sanbox V2X QoS Prediction is based on a grid Map of Monaco City where areas are categorized into residential, commercial and coastal. \n",
    "PoAs (Point Of Access) are categorized depending on where they lie in each grid. \n",
    "Each category has its own traffic load patterns which are pre-determin. The V2X QoS Prediction) will give more accurate values of RSRP and RSRQ based on the diurnal traffic patterns for each. The network scenario named \"4g-5g-v2x-macro\" must be used to get access to the V2X QoS Prediction feature.\n",
    "b>Note:</b > The MEC Sanbox V2X QoS Prediction is enabled when the PredictedQos.routes.routeInfo.time attribute is present in the request (see ETSI GS MEC 030 V3.2.1 (2024-02) Clause 6.2.6 Type: Preditecd Qoo\n",
    "\n",
    "- Limitations:\n",
    "* The Location Granularity is currently not being validated as RSRP/RSRP calculations are done at the exact location provided by the user.\n",
    "* Time Granularity is currently not supported by the Prediction Function (design limitations of the minimal, emulated, pre-determined traffic prediction)\n",
    "* \n",
    "Upper limit on the number of elements (10 each) in the routes and routeInfo structures (arrays) to not affect user experience and respoy\r\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The table below describes the excepted Qos with and without the prediction model in deiffrent area and at different time.\n",
    "\n",
    "\n",
    "|     Location        |               Time                  |      PoA         |  Category   |    Status     | QoS without Prediction Model | QoS with Prediction Model | Expected |\r\n",
    "| \t              | (Unix time in sec) | Standard (GMT) |                  |             |               |    RSRP        |   RSRQ      |    RSRP     |   RSRQ      |          |\r\n",
    "| ------------------- | -----------        | -------------- | ---------------- | ----------- | ------------- | -------------- | ----------- | ----------- | ----------- | -------- |\r\n",
    "| 43.729416,7.414853  |     1653295620     |    08:47:00    | 4g-macro-cell-2  | Residential | Congested     |     63         |     21      |     60      |     20      |   Yes    |\r\n",
    "| 43.732456,7.418417  |     1653299220     |    09:47:00    | 4g-macro-cell-3  | Residential | Not Congested |     55         |     13      |     55      |     13      |   Yes    |\r\n",
    "| 43.73692,7.4209256  |     1653302820     |    10:47:00    | 4g-macro-cell-6  | Coastal     | Not Congested |     68         |     26      |     68      |     26      |   Yes    |\r\n",
    "| 43.738007,7.4230533 |     1653305220     |    11:27:00    | 4g-macro-cell-6  | Coastal     | Not Congested |     55         |     13      |     55      |     13      |   Yes    |\r\n",
    "| 43.739685,7.424881  |     1653308820     |    12:27:00    | 4g-macro-cell-7  | Commercial  | Congested     |     63         |     21      |     40      |     13      |   Yes    |\r\n",
    "| 43.74103,7.425759   |     1653312600     |    13:30:00    | 4g-macro-cell-7  | Commercial  | Congested     |     56         |     14      |     40      |     8       |   Yes    |\r\n",
    "| 43.74258,7.4277945  |     1653315900     |    14:25:00    | 4g-macro-cell-8  | Coastal     | Congested     |     59         |     17      |     47      |     13      |   Yes    |\r\n",
    "| 43.744972,7.4295254 |     1653318900     |    15:15:00    | 4g-macro-cell-8  | Coastal     | Congested     |     53         |     11      |     40      |     5       |   Yes    |\r\n",
    "| 43.74773,7.4320855  |     1653322500     |    16:15:00    | 5g-small-cell-14 | Commercial  | Congested     |     78         |     69      |     60      |     53      |   Yes    |\r\n",
    "| 43.749264,7.435894  |     1653329700     |    18:15:00    | 5g-small-cell-20 | Commercial  | Not Congested |     84         |     72      |     84      |     72      |  Yes    |\t72\t84\t72\tYes\r\n",
    "\r\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The imge below illustrate the table above: [here](images/V2X Predicted QoS.jpg).\n",
    "\n",
    "Here is an example of a basic V2X predicted QoS request based on two point in path at 8am in Residential area:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```json\n",
    "{\r\n",
    "  \"predictionTarget\": \"SINGLE_UE_PREDICTION\",\r\n",
    "  \"timeGranularity\": null,\r\n",
    "  \"locationGranularity\": \"30\",\r\n",
    "  \"routes\": [\r\n",
    "      {\r\n",
    "        \"routeInfo\": [\r\n",
    "          {\r\n",
    "            \"location\": {\r\n",
    "              \"geoArea\": {\r\n",
    "                \"latitude\": 43.729416,\r\n",
    "                \"longitude\": 7.414853\r\n",
    "              }\r\n",
    "            },\r\n",
    "            \"time\": {\r\n",
    "              \"nanoSeconds\": 0,\r\n",
    "              \"seconds\": 1653295620\r\n",
    "            }\r\n",
    "          },\r\n",
    "          {\r\n",
    "              \"location\": {\r\n",
    "                \"geoArea\": {\r\n",
    "                  \"latitude\": 43.732456,\r\n",
    "                  \"longitude\": 7.418417\r\n",
    "                }\r\n",
    "              },\r\n",
    "            \"time\": {\r\n",
    "              \"nanoSeconds\": 0,\r\n",
    "              \"seconds\": 1653299220\r\n",
    "uest based on the JSON ab\n",
    "ove.\r\n",
    "        ]\r\n",
    "      }\r\n",
    "    ]\r\n",
    "}```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let first create the required types before to prepare a V2X Predicted QoS request based on the JSON above.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Routes(object):\n",
    "    swagger_types = {'_route_info': 'list[RouteInfo]'}\n",
    "    attribute_map = {'_route_info': 'routeInfo'}\n",
    "    def __init__(self, route_info:list):  # noqa: E501\n",
    "        self._route_info = None\n",
    "        self.route_info = route_info\n",
    "    @property\n",
    "    def route_info(self):\n",
    "        return self._route_info\n",
    "    @route_info.setter\n",
    "    def route_info(self, route_info):\n",
    "        if route_info is None:\n",
    "            raise ValueError(\"Invalid value for `route_info`, must not be `None`\")  # noqa: E501\n",
    "        self._route_info = route_info\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(Routes, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Routes):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class LocationInfo(object):\n",
    "    swagger_types = {'_ecgi': 'Ecgi', '_geo_area': 'LocationInfoGeoArea'}\n",
    "    attribute_map = {'_ecgi': 'ecgi', '_geo_area': 'geoArea'}\n",
    "    def __init__(self, ecgi=None, geo_area=None):  # noqa: E501\n",
    "        self._ecgi = None\n",
    "        self._geo_area = None\n",
    "        self.discriminator = None\n",
    "        if ecgi is not None:\n",
    "            self.ecgi = ecgi\n",
    "        if geo_area is not None:\n",
    "            self.geo_area = geo_area\n",
    "    @property\n",
    "    def ecgi(self):\n",
    "        return self._ecgi\n",
    "    @ecgi.setter\n",
    "    def ecgi(self, ecgi):\n",
    "        self._ecgi = ecgi\n",
    "    @property\n",
    "    def geo_area(self):\n",
    "        return self._geo_area\n",
    "    @geo_area.setter\n",
    "    def geo_area(self, geo_area):\n",
    "        self._geo_area = geo_area\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(LocationInfo, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, LocationInfo):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class RouteInfo(object):\n",
    "    swagger_types = {'_location': 'LocationInfo', '_time_stamp': 'TimeStamp'}\n",
    "    attribute_map = {'_location': 'location', '_time_stamp': 'time'}\n",
    "    def __init__(self, location:LocationInfo, time_stamp=None):  # noqa: E501\n",
    "        self._location = None\n",
    "        self.location = location\n",
    "        self._time_stamp = None\n",
    "        if time_stamp is not None:\n",
    "            self.time_stamp = time_stamp\n",
    "    @property\n",
    "    def location(self):\n",
    "        return self._location\n",
    "    @location.setter\n",
    "    def location(self, location):\n",
    "        if location is None:\n",
    "            raise ValueError(\"Invalid value for `location`, must not be `None`\")  # noqa: E501\n",
    "        self._location = location\n",
    "    @property\n",
    "    def time_stamp(self):\n",
    "        return self._time_stamp\n",
    "    @time_stamp.setter\n",
    "    def time_stamp(self, time_stamp):\n",
    "        self._time_stamp = time_stamp\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(RouteInfo, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, RouteInfo):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class LocationInfoGeoArea(object):\n",
    "    swagger_types = {'_latitude': 'float', '_longitude': 'float'}\n",
    "    attribute_map = {'_latitude': 'latitude', '_longitude': 'longitude'}\n",
    "    def __init__(self, latitude, longitude):  # noqa: E501\n",
    "        self._latitude = None\n",
    "        self._longitude = None\n",
    "        self.discriminator = None\n",
    "        if latitude is not None:\n",
    "            self.latitude = latitude\n",
    "        if longitude is not None:\n",
    "            self.longitude = longitude\n",
    "    @property\n",
    "    def latitude(self):\n",
    "        return self._latitude\n",
    "    @latitude.setter\n",
    "    def latitude(self, latitude):\n",
    "        if latitude is None:\n",
    "            raise ValueError(\"Invalid value for `latitude`, must not be `None`\")  # noqa: E501\n",
    "        self._latitude = latitude\n",
    "    @property\n",
    "    def longitude(self):\n",
    "        return self._longitude\n",
    "    @longitude.setter\n",
    "    def longitude(self, longitude):\n",
    "        if longitude is None:\n",
    "            raise ValueError(\"Invalid value for `longitude`, must not be `None`\")  # noqa: E501\n",
    "        self._longitude = longitude\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(LocationInfoGeoArea, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, LocationInfoGeoArea):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class Ecgi(object):\n",
    "    swagger_types = {'_cellId': 'CellId', '_plmn': 'Plmn'}\n",
    "    attribute_map = {'_cellId': 'cellId', '_plmn': 'plmn'}\n",
    "    def __init__(self, cellId=None, plmn=None):  # noqa: E501\n",
    "        self._cellId = None\n",
    "        self._plmn = None\n",
    "        self.discriminator = None\n",
    "        if cellId is not None:\n",
    "            self.cellId = cellId\n",
    "        if plmn is not None:\n",
    "            self.plmn = plmn\n",
    "    @property\n",
    "    def cellId(self):\n",
    "        return self._cellId\n",
    "    @cellId.setter\n",
    "    def cellId(self, cellId):\n",
    "        self._cellId = cellId\n",
    "    @property\n",
    "    def plmn(self):\n",
    "        return self._plmn\n",
    "    @plmn.setter\n",
    "    def plmn(self, plmn):\n",
    "        self._plmn = plmn\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(Ecgi, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Ecgi):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class CellId(object):\n",
    "    swagger_types = {'_cellId': 'str'}\n",
    "    attribute_map = {'_cellId': 'cellId'}\n",
    "    def __init__(self, cellId):  # noqa: E501\n",
    "        self._cellId = None\n",
    "        self.cellId = cellId\n",
    "    @property\n",
    "    def cellId(self):\n",
    "        return self._cellId\n",
    "    @cellId.setter\n",
    "    def cellId(self, cellId):\n",
    "        if cellId is None:\n",
    "            raise ValueError(\"Invalid value for `cellId`, must not be `None`\")  # noqa: E501\n",
    "        self._cellId = cellId\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(CellId, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, CellId):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class Plmn(object):\n",
    "    swagger_types = {'_mcc': 'str', '_mnc': 'str'}\n",
    "    attribute_map = {'_mcc': 'mcc', '_mnc': 'mnc'}\n",
    "    def __init__(self, mcc:str, mnc:str):  # noqa: E501\n",
    "        self.discriminator = None\n",
    "        self._mcc = None\n",
    "        self._mnc = None\n",
    "        self.mcc = mcc\n",
    "        self.mnc = mnc\n",
    "    @property\n",
    "    def mcc(self):\n",
    "        return self._mcc\n",
    "    @mcc.setter\n",
    "    def kpi_nmccame(self, mcc):\n",
    "        if mcc is None:\n",
    "            raise ValueError(\"Invalid value for `mcc`, must not be `None`\")  # noqa: E501\n",
    "        self._mcc = mcc\n",
    "    @property\n",
    "    def mnc(self):\n",
    "        return self._mnc\n",
    "    @mnc.setter\n",
    "    def kpi_nmccame(self, mnc):\n",
    "        if mnc is None:\n",
    "            raise ValueError(\"Invalid value for `mnc`, must not be `None`\")  # noqa: E501\n",
    "        self._mnc = mnc\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(Plmn, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Plmn):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class QosKpi(object):\n",
    "    swagger_types = {'_kpi_name': 'str', '_kpi_value': 'str', '_confidence': 'str'}\n",
    "    attribute_map = {'_kpi_name': 'kpiName', '_kpi_value': 'kpiValue', '_confidence': 'Confidence'}\n",
    "    def __init__(self, kpi_name:str, kpi_value:str, confidence=None):  # noqa: E501\n",
    "        self._kpi_name = None\n",
    "        self._kpi_value = None\n",
    "        self._confidence = None\n",
    "        self.kpi_name = kpi_name\n",
    "        self.kpi_value = kpi_value\n",
    "        if confidence is not None:\n",
    "            self.confidences = confidence\n",
    "    @property\n",
    "    def kpi_name(self):\n",
    "        return self._kpi_name\n",
    "    @kpi_name.setter\n",
    "    def kpi_name(self, kpi_name):\n",
    "        if kpi_name is None:\n",
    "            raise ValueError(\"Invalid value for `kpi_name`, must not be `None`\")  # noqa: E501\n",
    "        self._kpi_name = kpi_name\n",
    "    @property\n",
    "    def kpi_value(self):\n",
    "        return self._kpi_value\n",
    "    @kpi_value.setter\n",
    "    def kpi_value(self, kpi_value):\n",
    "        if kpi_value is None:\n",
    "            raise ValueError(\"Invalid value for `kpi_value`, must not be `None`\")  # noqa: E501\n",
    "        self._kpi_value = kpi_value\n",
    "    @property\n",
    "    def confidence(self):\n",
    "        return self._confidence\n",
    "    @confidence.setter\n",
    "    def confidence(self, confidence):\n",
    "        self._confidence = confidence\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,value))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(QosKpi, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, QosKpi):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class Stream(object):\n",
    "    swagger_types = {'_stream_id': 'str', '_qos_kpi': 'list[QosKpi]'}\n",
    "    attribute_map = {'_stream_id': 'streamId', '_qos_kpi': 'qosKpi'}\n",
    "    def __init__(self, stream_id:str, qos_kpi:list):  # noqa: E501\n",
    "        self._stream_id = None\n",
    "        self._qos_kpi = None\n",
    "        self.stream_id = stream_id\n",
    "        self.qos_kpi = qos_kpi\n",
    "    @property\n",
    "    def stream_id(self):\n",
    "        return self._stream_id\n",
    "    @stream_id.setter\n",
    "    def stream_id(self, stream_id):\n",
    "        if stream_id is None:\n",
    "            raise ValueError(\"Invalid value for `stream_id`, must not be `None`\")  # noqa: E501\n",
    "        self._stream_id = stream_id\n",
    "    @property\n",
    "    def qos_kpi(self):\n",
    "        return self._qos_kpi\n",
    "    @qos_kpi.setter\n",
    "    def qos_kpi(self, qos_kpi):\n",
    "        if qos_kpi is None:\n",
    "            raise ValueError(\"Invalid value for `qos_kpi`, must not be `None`\")  # noqa: E501\n",
    "        self._qos_kpi = qos_kpi\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(\n",
    "                    lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,\n",
    "                    value\n",
    "                ))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(Stream, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Stream):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class Qos(object):\n",
    "    swagger_types = {'_stream': 'list[Stream]'}\n",
    "    attribute_map = {'_stream': 'stream'}\n",
    "    def __init__(self, stream:list):  # noqa: E501\n",
    "        self._stream = None\n",
    "        self.stream = stream\n",
    "    @property\n",
    "    def stream(self):\n",
    "        return self._stream\n",
    "    @stream.setter\n",
    "    def stream(self, stream):\n",
    "        if stream is None:\n",
    "            raise ValueError(\"Invalid value for `stream`, must not be `None`\")  # noqa: E501\n",
    "        self._stream = stream\n",
    "    def to_dict(self):\n",
    "        result = {}\n",
    "        for attr, _ in six.iteritems(self.swagger_types):\n",
    "            value = getattr(self, attr)\n",
    "            if isinstance(value, list):\n",
    "                result[attr] = list(map(\n",
    "                    lambda x: x.to_dict() if hasattr(x, 'to_dict') else x,\n",
    "                    value\n",
    "                ))\n",
    "            elif hasattr(value, 'to_dict'):\n",
    "                result[attr] = value.to_dict()\n",
    "            elif isinstance(value, dict):\n",
    "                result[attr] = dict(map(\n",
    "                    lambda item: (item[0], item[1].to_dict())\n",
    "                    if hasattr(item[1], 'to_dict') else item,\n",
    "                    value.items()\n",
    "                ))\n",
    "            else:\n",
    "                result[attr] = value\n",
    "        if issubclass(Qos, dict):\n",
    "            for key, value in self.items():\n",
    "                result[key] = value\n",
    "        return result\n",
    "    def to_str(self):\n",
    "        return pprint.pformat(self.to_dict())\n",
    "    def __repr__(self):\n",
    "        return self.to_str()\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Qos):\n",
    "            return False\n",
    "        return self.__dict__ == other.__dict__\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "class PredictedQos(object):\n",
    "    swagger_types = {'_location_granularity': 'str', '_notice_period': 'TimeStamp', '_prediction_area': 'PredictionArea', '_prediction_target': 'str', '_qos': 'Qos', '_routes': 'list[Routes]', '_time_granularity': 'TimeStamp'}\n",
    "    attribute_map = {'_location_granularity': 'locationGranularity', '_notice_period': 'noticePeriod', '_prediction_area': 'predictionArea', '_prediction_target': 'predictionTarget', '_qos': 'qos', '_routes': 'routes', '_time_granularity': 'timeGranularity'}\n",
    "    def __init__(self, prediction_target:str, location_granularity:str, notice_period=None, time_granularity=None, prediction_area=None, routes=None, qos=None):  # noqa: E501\n",
    "        self._prediction_target = None\n",
    "        self._time_granularity = None\n",
    "        self._location_granularity = None\n",
    "        self._notice_period = None\n",
    "        self._prediction_area = None\n",
    "        self._routes = None\n",
    "        self._qos = None\n",
    "        self._prediction_target = prediction_target\n",
    "        if time_granularity is not None:\n",
    "            self.time_granularity = time_granularity\n",
    "        self.location_granularity = location_granularity\n",
    "        if notice_period is not None:\n",
    "            self.notice_period = notice_period\n",
    "        if prediction_area is not None:\n",
    "            self.prediction_area = prediction_area\n",
    "        if routes is not None:\n",
    "            self.routes = routes\n",
    "        if qos is not None:\n",
    "            self.qos = qos\n",
    "    @property\n",
    "    def prediction_target(self):\n",
    "        return self._prediction_target\n",
    "    @prediction_target.setter\n",
    "    def prediction_target(self, prediction_target):\n",
    "        if prediction_target is None:\n",
    "            raise ValueError(\"Invalid value for `prediction_target`, must not be `None`\")  # noqa: E501\n",
    "        self._prediction_target = prediction_target\n",
    "    @property\n",
    "    def time_granularity(self):\n",
    "        return self._time_granularity\n",
    "    @time_granularity.setter\n",
    "    def time_granularity(self, time_granularity):\n",
    "        self._time_granularity = time_granularity\n",
    "    @property\n",
    "    def location_granularity(self):\n",
    "        return self._location_granularity\n",
    "    @location_granularity.setter\n",
    "    def location_granularity(self, location_granularity):\n",
    "        if location_granularity is None:\n",
    "            raise ValueError(\"Invalid value for `location_granularity`, must not be `None`\")  # noqa: E501\n",
    "        self._location_granularity = location_granularity\n",
    "    @property\n",
    "    def notice_period(self):\n",
    "        return self._notice_period\n",
    "    @notice_period.setter\n",
    "    def notice_period(self, notice_period):\n",
    "        self._notice_period = notice_period\n",
    "    @property\n",
    "    def prediction_area(self):\n",