create_wms_template_appmode.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f075e610d90c4c05b4a43a56eca59069",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HTML(value='\\n    <style>\\n        .output_scroll {\\n            height: unset !important;\\n            border…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import xml.etree.ElementTree as ET\n",
    "from io import StringIO\n",
    "import requests\n",
    "from collections import OrderedDict\n",
    "import json\n",
    "from urllib.parse import urlparse, parse_qsl, urlencode, urlunparse\n",
    "from ipywidgets import interact, interactive, FloatSlider, interact_manual, HTML\n",
    "import pyproj\n",
    "\n",
    "style = \"\"\"\n",
    "    <style>\n",
    "        .output_scroll {\n",
    "            height: unset !important;\n",
    "            border-radius: unset !important;\n",
    "            -webkit-box-shadow: unset !important;\n",
    "            box-shadow: unset !important;\n",
    "        }\n",
    "    </style>\n",
    "    \"\"\"\n",
    "display(HTML(style))\n",
    "\n",
    "\n",
    "def parse_wms(xml):\n",
    "    \"\"\" Rudimentary parsing of WMS Layers from GetCapabilites Request\n",
    "        owslib.wms seems to have problems parsing some weird not relevant metadata.\n",
    "        This function aims at only parsing relevant layer metadata\n",
    "    \"\"\"\n",
    "    wms = {}\n",
    "    try:\n",
    "        it = ET.iterparse(StringIO(xml))\n",
    "        for _, el in it:\n",
    "            prefix, has_namespace, postfix = el.tag.partition('}')\n",
    "            if has_namespace:\n",
    "                el.tag = postfix\n",
    "        root = it.root\n",
    "    except:\n",
    "        raise RuntimeError(\"Could not parse XML.\")\n",
    "\n",
    "    root_tag = root.tag.rpartition(\"}\")[-1]\n",
    "    if root_tag in {'ServiceExceptionReport', 'ServiceException'}:\n",
    "        raise RuntimeError(\"WMS service exception\")\n",
    "\n",
    "    if root_tag not in {'WMT_MS_Capabilities', 'WMS_Capabilities'}:\n",
    "        raise RuntimeError(\"No Capabilities Element present: Root tag: {}\".format(root_tag))\n",
    "\n",
    "    if 'version' not in root.attrib:\n",
    "        raise RuntimeError(\"WMS version cannot be identified.\")\n",
    "    version = root.attrib['version']\n",
    "    wms['version'] = version\n",
    "\n",
    "    layers = {}\n",
    "\n",
    "    def parse_layer(element, crs=set(), styles={}):\n",
    "        new_layer = {'CRS': crs,\n",
    "                     'Styles': {}}\n",
    "        new_layer['Styles'].update(styles)\n",
    "        for tag in ['Name', 'Title', 'Abstract']:\n",
    "            e = element.find(\"./{}\".format(tag))\n",
    "            if e is not None:\n",
    "                new_layer[e.tag] = e.text\n",
    "        for tag in ['CRS', 'SRS']:\n",
    "            es = element.findall(\"./{}\".format(tag))\n",
    "            for e in es:\n",
    "                new_layer[\"CRS\"].add(e.text.upper())\n",
    "        for tag in ['Style']:\n",
    "            es = element.findall(\"./{}\".format(tag))\n",
    "            for e in es:\n",
    "                new_style = {}\n",
    "                for styletag in ['Title', 'Name']:\n",
    "                    new_style[styletag] = e.find(\"./{}\".format(styletag)).text\n",
    "                new_layer[\"Styles\"][new_style['Name']] = new_style\n",
    "\n",
    "        if 'Name' in new_layer:\n",
    "            layers[new_layer['Name']] = new_layer\n",
    "\n",
    "        for sl in element.findall(\"./Layer\"):\n",
    "            parse_layer(sl,\n",
    "                        new_layer['CRS'].copy(),\n",
    "                        new_layer['Styles'])\n",
    "\n",
    "    # Find child layers. CRS and Styles are inherited from parent\n",
    "    top_layers = root.findall(\".//Capability/Layer\")\n",
    "    for top_layer in top_layers:\n",
    "        parse_layer(top_layer)\n",
    "\n",
    "    wms['layers'] = layers\n",
    "\n",
    "    # Parse formats\n",
    "    formats = []\n",
    "    for es in root.findall(\".//Capability/Request/GetMap/Format\"):\n",
    "        formats.append(es.text)\n",
    "    wms['formats'] = formats\n",
    "    \n",
    "    # Parse access constraints and fees\n",
    "    constraints = []\n",
    "    for es in root.findall(\".//AccessConstraints\"):\n",
    "        constraints.append(es.text)\n",
    "    fees = []\n",
    "    for es in root.findall(\".//Fees\"):\n",
    "        fees.append(es.text)\n",
    "    wms['Fees'] = fees\n",
    "    wms['AccessConstraints'] = constraints \n",
    "    \n",
    "    \n",
    "    return wms\n",
    "\n",
    "\n",
    "epsg_3857_alias = set(\n",
    "    [\n",
    "        \"EPSG:{}\".format(epsg)\n",
    "        for epsg in [900913, 3587, 54004, 41001, 102113, 102100, 3785]\n",
    "    ]\n",
    ")\n",
    "\n",
    "# List of not deprecated EPSG codes\n",
    "valid_epsgs = set([\"CRS:84\"])\n",
    "for pj_type in pyproj.enums.PJType:\n",
    "    valid_epsgs.update(\n",
    "        map(\n",
    "            lambda x: \"EPSG:{}\".format(x),\n",
    "            pyproj.get_codes(\"EPSG\", pj_type, allow_deprecated=False),\n",
    "        )\n",
    "    )\n",
    "\n",
    "# EPSG:3857 alias are valid if server does not support EPSG:3857\n",
    "valid_epsgs.update(epsg_3857_alias)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating a WMS template\n",
    "\n",
    "This Jupyter notebook can be used to generate a template using a WMS Server.\n",
    "\n",
    "Insert a WMS url (e.g. `https://wms.zh.ch/OGDLidarZH?SERVICE=WMS&Request=GetCapabilities`) in the input box below and press enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://opengeodata.goteborg.se/services/hojdmodell/wms/v2\n",
      "\n",
      "Send request to: https://opengeodata.goteborg.se/services/hojdmodell/wms/v2?service=WMS&request=GetCapabilities&version=1.3.0\n",
      "\n",
      "WMS Server Metadata:\n",
      "Access constraints:\n",
      "NONE\n",
      "\n",
      "Fees:\n",
      "NONE\n",
      "\n",
      "Layers:\n",
      "0: hojdgrid (HÃ¶jdgrid)\n",
      "1: hojdkurvor (HÃ¶jdkurvor)\n",
      "2: terranglutning (TerrÃ¤nglutning)\n",
      "3: terrangskuggning (TerrÃ¤ngskuggning)\n",
      " \n",
      "Select Layer: 2\n",
      " \n",
      "Styles:\n",
      "0: hojdmodell-v2:terranglutning (Terranglutning)\n",
      " \n",
      "Select Style: 0\n",
      " \n",
      "Image formats:\n",
      "image/jpeg is typically preferred for photo sources. But might not always be the best choice.\n",
      "0: image/png\n",
      "1: image/geotiff8\n",
      "2: image/jpeg\n",
      "3: image/png; mode=8bit\n",
      " \n",
      "Select Format: 2\n",
      " \n",
      "\n",
      "Copy the following output:\n",
      "-------------------------\n",
      "{\n",
      "    \"type\": \"Feature\",\n",
      "    \"properties\": {\n",
      "        \"name\": \"Terr\\u00c3\\u00a4nglutning\",\n",
      "        \"type\": \"wms\",\n",
      "        \"url\": \"https://opengeodata.goteborg.se/services/hojdmodell/wms/v2?LAYERS=terranglutning&STYLES=hojdmodell-v2:terranglutning&FORMAT=image/jpeg&CRS={proj}&WIDTH={width}&HEIGHT={height}&BBOX={bbox}&VERSION=1.3.0&SERVICE=WMS&REQUEST=GetMap\",\n",
      "        \"license_url\": \"\",\n",
      "        \"privacy_policy_url\": \"\",\n",
      "        \"id\": \"\",\n",
      "        \"description\": \"Terr\\u00c3\\u00a4nglutning med lutningsintervall i gr\\u00c3\\u00a5skala fr\\u00c3\\u00a5n vitt till svart. 100% opacitet.\",\n",
      "        \"country_code\": \"\",\n",
      "        \"best\": false,\n",
      "        \"start_date\": \"\",\n",
      "        \"end_date\": \"\",\n",
      "        \"category\": \"\",\n",
      "        \"available_projections\": [\n",
      "            \"CRS:84\",\n",
      "            \"EPSG:3006\",\n",
      "            \"EPSG:3007\"\n",
      "        ],\n",
      "        \"attribution\": {\n",
      "            \"url\": \"\",\n",
      "            \"text\": \"\",\n",
      "            \"html\": \"\",\n",
      "            \"required\": true\n",
      "        }\n",
      "    },\n",
      "    \"geometry\": \"\"\n",
      "}\n",
      "-------------------------\n"
     ]
    }
   ],
   "source": [
    "wms_url = input()\n",
    "\n",
    "def run_wms_wizard(wms_url):\n",
    "    wms_args = {}\n",
    "    u = urlparse(wms_url)\n",
    "    url_parts = list(u)\n",
    "    for k, v in parse_qsl(u.query):\n",
    "        wms_args[k.lower()] = v\n",
    "\n",
    "    def get_getcapabilitie_url(wms_version=None):\n",
    "\n",
    "        get_capabilities_args = {'service': 'WMS',\n",
    "                                 'request': 'GetCapabilities'}\n",
    "        if wms_version is not None:\n",
    "            get_capabilities_args['version'] = wms_version\n",
    "\n",
    "        # Keep extra arguments, such as map or key\n",
    "        for key in wms_args:\n",
    "            if key not in {'version', 'request', 'layers', 'bbox', 'width', 'height', 'format', 'crs', 'srs'}:\n",
    "                get_capabilities_args[key] = wms_args[key]\n",
    "\n",
    "        url_parts[4] = urlencode(list(get_capabilities_args.items()))\n",
    "        return urlunparse(url_parts)\n",
    "\n",
    "\n",
    "    print(\"\")\n",
    "    wms = None\n",
    "    for wmsversion in ['1.3.0', '1.1.1', '1.1.0', '1.0.0', None]:\n",
    "        url = get_getcapabilitie_url(wms_version=wmsversion)\n",
    "        try:\n",
    "            print(\"Send request to: {}\".format(url))\n",
    "            r = requests.get(url)\n",
    "            xml = r.text\n",
    "            wms = parse_wms(xml)\n",
    "            break\n",
    "        except Exception as e:\n",
    "            print(str(e))\n",
    "    if not wms:\n",
    "        print(\"Could not contact WMS server\")\n",
    "    \n",
    "\n",
    "    print(\"\")\n",
    "    print(\"WMS Server Metadata:\")\n",
    "\n",
    "    if len(wms['AccessConstraints']) > 0:\n",
    "        print(\"Access constraints:\")\n",
    "        for cs in wms['AccessConstraints']:\n",
    "            print(cs)\n",
    "    print(\"\")\n",
    "    if len(wms['Fees']) > 0:\n",
    "        print(\"Fees:\")\n",
    "        for fee in wms['Fees']:\n",
    "            print(fee)\n",
    "    print(\"\")\n",
    "    print(\"Layers:\")\n",
    "    layers = list(wms['layers'].keys())\n",
    "    for i, layer in enumerate(layers):\n",
    "        print(\"{}: {} ({})\".format(i,\n",
    "                                   layers[i],\n",
    "                                   wms['layers'][layer]['Title']))\n",
    "\n",
    "    print(\" \")\n",
    "    selected_layer_idx = int(input(\"Select Layer: \"))\n",
    "    print(\" \")\n",
    "\n",
    "    assert 0 <= selected_layer_idx < len(layers)\n",
    "    selected_layer = layers[selected_layer_idx]\n",
    "    description = ''\n",
    "    if 'Abstract' in wms['layers'][selected_layer] and wms['layers'][selected_layer]['Abstract'] is not None:\n",
    "        description = wms['layers'][selected_layer]['Abstract']\n",
    "    layer_title = ''\n",
    "    if 'Title' in wms['layers'][selected_layer] and wms['layers'][selected_layer]['Title'] is not None:\n",
    "        layer_title = wms['layers'][selected_layer]['Title']\n",
    "\n",
    "    crs_options = set(wms['layers'][selected_layer]['CRS'])\n",
    "\n",
    "    styles = list(wms['layers'][selected_layer]['Styles'].keys())\n",
    "    selected_style = None\n",
    "    if len(styles) > 0:\n",
    "        print(\"Styles:\")\n",
    "        for i, style in enumerate(styles):\n",
    "            print(\"{}: {} ({})\".format(i, style, (wms['layers'][selected_layer]['Styles'][style]['Title'])))\n",
    "        print(\" \")\n",
    "        selected_style_idx = int(input(\"Select Style: \"))\n",
    "        print(\" \")\n",
    "\n",
    "        assert 0 <= selected_style_idx < len(styles)\n",
    "        selected_style = styles[selected_style_idx]\n",
    "    else:\n",
    "        selected_style = ''\n",
    "\n",
    "    print(\"Image formats:\")\n",
    "    print(\"image/jpeg is typically preferred for photo sources. But might not always be the best choice.\")\n",
    "    format_options = wms['formats']\n",
    "    for i, format_option in enumerate(format_options):\n",
    "        print(\"{}: {}\".format(i, format_option))\n",
    "\n",
    "    print(\" \")\n",
    "    selected_format_idx = int(input(\"Select Format: \"))\n",
    "    print(\" \")\n",
    "    assert 0 <= selected_format_idx < len(format_options)\n",
    "    selected_format = format_options[selected_format_idx]\n",
    "\n",
    "    wms_paramters = {}\n",
    "    if 'map' in wms_args:\n",
    "        wms_paramters['MAP'] = wms_args['map']\n",
    "    wms_paramters['LAYERS'] = selected_layer\n",
    "    if selected_style is not None:\n",
    "        wms_paramters['STYLES'] = selected_style\n",
    "    wms_paramters['FORMAT'] = selected_format\n",
    "    if wms['version'] == '1.3.0': \n",
    "        wms_paramters['CRS'] = '{proj}'\n",
    "    else:\n",
    "        wms_paramters['SRS'] = '{proj}'\n",
    "    wms_paramters['WIDTH'] = '{width}'\n",
    "    wms_paramters['HEIGHT'] = '{height}'\n",
    "    wms_paramters['BBOX'] = '{bbox}'\n",
    "    wms_paramters['VERSION'] = wms['version']\n",
    "    wms_paramters['SERVICE'] = 'WMS'\n",
    "    wms_paramters['REQUEST'] = 'GetMap'\n",
    "\n",
    "    baseurl = wms_url.split(\"?\")[0]\n",
    "    service_url = baseurl + \"?\" + \"&\".join([\"{}={}\".format(key, value) for key, value in wms_paramters.items()])\n",
    "\n",
    "    # Filter alias projections\n",
    "    if \"EPSG:3857\" in crs_options:\n",
    "        crs_options -= epsg_3857_alias\n",
    "    else:\n",
    "        # if EPSG:3857 not present but alias, keep only alias with highest number to be consistent\n",
    "        result_epsg_3857_alias = crs_options & epsg_3857_alias\n",
    "        result_epsg_3857_alias_sorted = list(\n",
    "            sorted(\n",
    "                result_epsg_3857_alias,\n",
    "                key=lambda x: (x.split(\":\")[0], int(x.split(\":\")[1])),\n",
    "                reverse=True,\n",
    "            )\n",
    "        )\n",
    "        crs_options -= set(result_epsg_3857_alias_sorted[1:])\n",
    "\n",
    "    # Filter deprecated projections\n",
    "    crs_options.intersection_update(valid_epsgs)\n",
    "\n",
    "    result = OrderedDict()\n",
    "    result['type'] = 'Feature'\n",
    "    result['properties'] = OrderedDict()\n",
    "    result['properties']['name'] = layer_title\n",
    "    result['properties']['type'] = 'wms'\n",
    "    result['properties']['url'] = service_url\n",
    "    result['properties']['license_url'] = ''\n",
    "    result['properties']['privacy_policy_url'] = ''\n",
    "    result['properties']['id'] = ''\n",
    "    result['properties']['description'] = description\n",
    "    result['properties']['country_code'] = ''\n",
    "    result['properties']['best'] = False\n",
    "    result['properties']['start_date'] = ''\n",
    "    result['properties']['end_date'] = ''\n",
    "    result['properties']['category'] = ''\n",
    "    result['properties']['available_projections'] = list(sorted(crs_options, key=lambda x: (x.split(':')[0], int(x.split(':')[1]))))\n",
    "    result['properties']['attribution'] = {'url': '',\n",
    "                                           'text': '',\n",
    "                                           'html': '',\n",
    "                                           'required': True}\n",
    "    result['geometry'] = ''\n",
    "\n",
    "\n",
    "    print(\"\")\n",
    "    print(\"Copy the following output:\")\n",
    "    print(\"-------------------------\")\n",
    "    print(json.dumps(result,\n",
    "                     indent=4,\n",
    "                     sort_keys=False))\n",
    "    print(\"-------------------------\")\n",
    "\n",
    "run_wms_wizard(wms_url)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}