django-gisserver 1.5.0__py3-none-any.whl → 2.0__py3-none-any.whl

gisserver/parsers/xml.py

@@ -0,0 +1,249 @@
+"""XML parsing for all incoming requests.
+
+This logic uses the etree logic from the standard library,
+with some extra extensions to expose the original namespace aliases.
+Using defusedxml, incoming DOS attacks are prevented.
+
+To handle more complex XML structures, consider building an Abstract Syntax Tree (AST)
+to translate the XML Element classes into Python objects.
+The :mod:`gisserver.parsers.ast` module provides the building blocks for that.
+"""
+
+from __future__ import annotations
+
+import logging
+import typing
+from enum import Enum
+from xml.etree.ElementTree import Element, QName, TreeBuilder
+
+from defusedxml.ElementTree import DefusedXMLParser, ParseError
+
+from gisserver.exceptions import ExternalParsingError, wrap_parser_errors
+
+logger = logging.getLogger(__name__)
+
+__all__ = (
+    "xmlns",
+    "NSElement",
+    "parse_xml_from_string",
+    "parse_qname",
+    "split_ns",
+)
+
+
+class xmlns(Enum):
+    """Common namespaces within WFS land.
+    Note these short aliases are arbitrary in XML syntax; the XML code may use any alias (such as ns0).
+    The full qualified name (e.g. ``<{http://www.opengis.net/gml/3.2}Point>``) is the actual tag name.
+    """
+
+    # XML standard
+    xml = "http://www.w3.org/XML/1998/namespace"
+    xsd = "http://www.w3.org/2001/XMLSchema"
+    xsi = "http://www.w3.org/2001/XMLSchema-instance"
+    xlink = "http://www.w3.org/1999/xlink"
+
+    # APIs by the Open Geospatial Consortium (OGC)
+    ogc = "http://www.opengis.net/ogc"
+    ows10 = "http://www.opengis.net/ows"  # OGC Web Service (OWS) base classes
+    ows11 = "http://www.opengis.net/ows/1.1"
+    ows20 = "http://www.opengis.net/ows/2.0"
+    wms = "http://www.opengis.net/wms"  # Web Map Service (WMS)
+    wcs = "http://www.opengis.net/wcs"  # Web Coverage Service (WCS)
+    wps = "http://www.opengis.net/wps/1.0.0"  # Web Processing Service (WPS)
+    wmts = "http://www.opengis.net/wmts/1.0"  # Web Map Tile Service (WMTS)
+    wfs20 = "http://www.opengis.net/wfs/2.0"  # Web Feature Service (WFS)
+    fes20 = "http://www.opengis.net/fes/2.0"  # Filter Encoding Standard (FES)
+    gml21 = "http://www.opengis.net/gml"
+    gml32 = "http://www.opengis.net/gml/3.2"
+
+    # Internal aliases
+    ows = ows11  # alias to currently used version (WFS 2.0 uses OWS 1.1)
+    wfs = wfs20
+    fes = fes20
+    gml = gml32  # alias to latest version
+    xs = xsd  # commonly used
+
+    @classmethod
+    def as_ns_aliases(cls) -> dict[str, str]:
+        """Map the namespaces as {alias: uri}"""
+        return {prefix: member.value for prefix, member in cls.__members__.items()}
+
+    @classmethod
+    def as_namespaces(cls) -> dict[str, str]:
+        """Map the namespaces as {uri: alias}. This will use the common aliases (without version numbers)"""
+        return {member.value: prefix for prefix, member in cls._member_map_.items()}
+
+    def __str__(self):
+        # Python 3.11+ has StrEnum for this.
+        return self.value
+
+    def qname(self, local_name) -> str:
+        """Convert the tag name into a fully qualified name."""
+        return f"{{{self.value}}}{local_name}"  # same as QName(..).text
+
+    def __contains__(self, tag: NSElement | str) -> bool:
+        """Tell whether a given tag exists in this namespace"""
+        if isinstance(tag, NSElement):
+            tag = tag.tag
+        elif not isinstance(tag, str):
+            return False
+        return tag.startswith(f"{{{self.value}}}")
+
+
+class NSElement(Element):
+    """Custom XML element, which also exposes its original namespace aliases.
+    That information is needed to parse text content and attributes in WFS
+    that hold a QName value. For example:
+
+    * ``<ValueReference>ns0:elementName</ValueReference>``
+    * ``<Query typeNames="ns1:name">``
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.ns_aliases = {}  # assigned by NSTreeBuilder, in {prefix: uri} format.
+
+    def parse_qname(self, qname: str) -> str:
+        """Resolve an aliased QName value to its fully qualified name."""
+        return parse_qname(qname, self.ns_aliases)
+
+    def get_str_attribute(self, name: str) -> str:
+        """Resolve an attribute, raise an error when it's missing."""
+        try:
+            return self.attrib[name]
+        except KeyError:
+            raise ExternalParsingError(
+                f"Element {self.tag} misses required attribute '{name}'"
+            ) from None
+
+    def get_int_attribute(self, name: str, default=None) -> int | None:
+        """Retrieve the integer value from an element attribute."""
+        value = self.attrib.get(name)
+        if value is None:
+            return default
+
+        with wrap_parser_errors(name, locator=name):
+            return int(value)
+
+    if typing.TYPE_CHECKING:
+        # Make sure the type checking knows the actual type of the elements.
+        def find(self, path: str, namespaces: dict[str, str] | None = None) -> NSElement | None:
+            return super().find(path, namespaces)
+
+        def findall(self, path: str, namespaces: dict[str, str] | None = None) -> list[NSElement]:
+            return super().findall(path, namespaces)
+
+        def __iter__(self) -> typing.Iterator[NSElement]:
+            return super().__iter__()
+
+
+def parse_qname(qname: str | None, ns_aliases: dict) -> str | None:
+    """Resolve the QName aliases.
+
+    For example, ``gml:Point`` will be resolved to ``{http://www.opengis.net/gml/3.2}Point``.
+    The XML namespace prefix is a custom alias, so if "ns0" is declared as "http://www.opengis.net/gml/3.2",
+    it means "ns0:Point" should resolve to the same fully qualified type name.
+    """
+    if not qname:
+        return None
+
+    if "/" in qname:
+        raise ExternalParsingError(f"Can't resolve QName '{qname}', this is an XPath notation.")
+
+    # Allow resolving @gml:id, remove the @ sigm.
+    is_attribute = qname[0] == "@"
+    if is_attribute:
+        qname = qname[1:]
+
+    prefix, _, localname = qname.rpartition(":")
+    if not prefix and ("" not in ns_aliases or ns_aliases[""] == xmlns.wfs20.value):
+        # In case a request uses <GetFeature xmlns="http://www.opengis.net/wfs/2.0">,
+        # non-prefixed QName values will be interpreted as existing in "wfs" namespace. Avoid that.
+        full_name = localname
+    else:
+        try:
+            uri = ns_aliases[prefix]
+        except KeyError:
+            logger.debug("Can't resolve QName '%s', available namespaces: %r", qname, ns_aliases)
+            raise ExternalParsingError(
+                f"Can't resolve QName '{qname}', an XML namespace declaration is missing."
+            ) from None
+
+        full_name = QName(uri, localname).text
+
+    return f"@{full_name}" if is_attribute else full_name
+
+
+class NSTreeBuilder(TreeBuilder):
+    """Custom TreeBuilder to track namespaces."""
+
+    def __init__(self, extra_ns_aliases, **kwargs):
+        super().__init__(element_factory=NSElement, **kwargs)
+        # A new stack level is added directly, as start_ns() is called before start()
+        if extra_ns_aliases:
+            self.ns_stack = [extra_ns_aliases, {}]
+        else:
+            self.ns_stack = [{}]
+
+    def start(self, tag, attrs):
+        super().start(tag, attrs)
+        self.ns_stack.append({})  # reserve stack for child tags
+
+    def start_ns(self, prefix, uri):
+        self.ns_stack[-1][prefix] = uri
+
+    def end(self, tag) -> Element:
+        element = super().end(tag)
+        self.ns_stack.pop()  # clear reservation for child tags
+        element.ns_aliases = self._flatten_ns()
+        return element
+
+    def _flatten_ns(self) -> dict:
+        result = {}
+        for level in self.ns_stack:
+            result.update(level)
+        return result
+
+
+def parse_xml_from_string(
+    xml_string: str | bytes, extra_ns_aliases: dict[str, str] | None = None
+) -> NSElement:
+    """Provide a safe and consistent way for parsing XML.
+
+    This uses a custom parser, so namespace aliases can be tracked.
+    All elements also have an :attr:`ns_aliases` attribute that exposes
+    the original alias that was used for the namespace.
+    """
+    # Passing a custom parser potentially circumvents defusedxml,
+    # so note the parser is again configured in the same way:
+    parser = DefusedXMLParser(
+        target=NSTreeBuilder(extra_ns_aliases=extra_ns_aliases),
+        forbid_dtd=True,
+        forbid_entities=True,
+        forbid_external=True,
+    )
+
+    # Not allowing DTD, do a primitive strip, and allow parsing to fail if it was mangled.
+    if isinstance(xml_string, str) and xml_string.startswith("<?"):
+        xml_string = xml_string[xml_string.find("?>") + 2 :]
+
+    try:
+        parser.feed(xml_string)
+        return parser.close()
+    except ParseError as e:
+        # Offer consistent results for callers to check for invalid data.
+        logger.debug("Parsing XML error: %s: %s", e, xml_string)
+        raise ExternalParsingError(str(e)) from e
+
+
+def split_ns(xml_name: str) -> tuple[str | None, str]:
+    """Split the element tag or attribute/text value into the namespace and
+    local name. The stdlib etree doesn't have the properties for this (lxml does).
+    """
+    # Tags may start with a `{ns}`
+    if xml_name.startswith("{"):
+        end = xml_name.index("}")
+        return xml_name[1:end], xml_name[end + 1 :]
+    else:
+        return None, xml_name

gisserver/projection.py

@@ -0,0 +1,357 @@
+"""In WFS, a "projection" is placed on top of the queried data.
+
+It translates the incoming data into the subset of properties to display.
+Practically, this code does inform and adjust the constructed QuerySet
+to make sure it will provide only the actual fields that are part of the projection.
+"""
+
+from __future__ import annotations
+
+import itertools
+import logging
+import operator
+import typing
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from functools import cached_property
+
+from gisserver.types import (
+    GeometryXsdElement,
+    XPathMatch,
+    XsdElement,
+    XsdNode,
+    XsdTypes,
+    _XsdElement_WithComplexType,
+)
+
+if typing.TYPE_CHECKING:
+    from django.contrib.gis.geos import GEOSGeometry
+    from django.db import models
+
+    from gisserver.features import FeatureType
+    from gisserver.geometries import CRS
+    from gisserver.parsers import fes20, wfs20
+
+__all__ = (
+    "FeatureProjection",
+    "FeatureRelation",
+)
+
+logger = logging.getLogger(__name__)
+
+
+class FeatureProjection:
+    """Tell which fields to access and render for a single feature.
+    This is inspired on 'fes:AbstractProjectionClause'.
+
+    Instead of walking over the full XSD object tree,
+    this object wraps that and makes sure only the actual requested fields are used.
+    When a PROPERTYNAME is used in the request, this will limit
+    which fields to retrieve, which to prefetch, and which to render.
+    """
+
+    feature_type: FeatureType
+    xsd_root_elements: list[XsdElement]
+    xsd_child_nodes: dict[XsdElement | None, list[XsdElement]]
+
+    def __init__(
+        self,
+        feature_types: list[FeatureType],
+        property_names: list[wfs20.PropertyName] | None = None,
+        value_reference: fes20.ValueReference | None = None,
+        output_crs: CRS | None = None,
+        output_standalone: bool = False,
+    ):
+        """
+
+        :param feature_types: The feature types used by this query. Typically one, unless there is a JOIN.
+        :param property_names: Limited list of fields to render only.
+        :param value_reference: Single element to display fo GetPropertyValue
+        :param output_crs: Which coordinate reference system to use for geometry data.
+        :param output_standalone: Whether the ``<wfs:
+        """
+        self.feature_types = feature_types
+        self.feature_type = feature_types[0]  # JOIN still not supported.
+        self.property_names = property_names
+        self.value_reference = value_reference
+        self.output_crs: CRS = output_crs or self.feature_type.crs
+        self.output_standalone = output_standalone  # for GetFeatureById
+        self._extra_matches = []
+
+        if property_names:
+            # Only a selection of the tree will be rendered.
+            # Discover which elements should be rendered.
+            child_nodes = self._get_child_nodes_subset()
+            self.xsd_root_elements = child_nodes.pop(None)  # Pop it to avoid recursion risks
+            self.xsd_child_nodes = child_nodes
+        else:
+            # All elements of the tree will be rendered, retrieve all elements.
+            # Note xsd_child_nodes can be altered below, so don't assign it a cached property.
+            self.xsd_root_elements = self.feature_type.xsd_type.elements_including_base
+            self.xsd_child_nodes = {
+                node: node.type.elements
+                for node in self.feature_type.xsd_type.all_complex_elements
+            }
+
+    def _get_child_nodes_subset(self) -> dict[XsdElement | None, list[XsdElement]]:
+        """Translate the PROPERTYNAME into a dictionary of nodes to render."""
+        child_nodes = defaultdict(list)
+        for xpath_match in self.xpath_matches:
+            # Make sure the tree is known beforehand, and it has no duplicate parent nodes.
+            # (e.g. PROPERTYNAME=node/child1,node/child2)
+            parent = None
+            for xsd_node in xpath_match.nodes:
+                if xsd_node not in child_nodes[parent]:
+                    child_nodes[parent].append(xsd_node)
+                parent = xsd_node
+
+        return dict(child_nodes)
+
+    def add_field(self, xsd_element: XsdElement):
+        """Restore the retrieval of a field that was not asked for in the original query."""
+        if xsd_element.type.is_complex_type:
+            raise NotImplementedError("Can't restore nested elements right now")
+        if not self.property_names or xsd_element in self.xsd_root_elements:
+            return
+
+        logger.debug("Projection: added %s", xsd_element)
+        self.xsd_root_elements.append(xsd_element)
+        self._extra_matches.append(XPathMatch(self.feature_type, [xsd_element], ""))
+        _clear_cached_properties(self)
+
+    def remove_fields(self, predicate: Callable[[XsdElement], bool]):
+        """Remove elements from the projection based on a given rule.
+        This helps to remove M2M and Array elements for CSV output for example.
+
+        Make sure this function is called as early as possible,
+        before other logic already read these attributes.
+        """
+        self.xsd_root_elements, removed_nodes = _partition(predicate, self.xsd_root_elements)
+
+        for xsd_child_root, xsd_child_elements in self.xsd_child_nodes.items():
+            if xsd_child_root in removed_nodes:
+                continue  # already removed the top-level, don't bother checking here
+
+            keep_children, remove_children = _partition(predicate, xsd_child_elements)
+            self.xsd_child_nodes[xsd_child_root] = keep_children
+            removed_nodes.update(remove_children)
+
+        # Remove complete trees if their parent was removed.
+        for xsd_child_root in list(self.xsd_child_nodes):
+            if xsd_child_root in removed_nodes:
+                self.xsd_child_nodes.pop(xsd_child_root, None)
+
+        if logger.isEnabledFor(logging.DEBUG) and removed_nodes:
+            logger.debug("Projection: removed %s", removed_nodes)
+
+        _clear_cached_properties(self)
+
+    @cached_property
+    def _geometry_getter(self):
+        return operator.attrgetter(self.main_geometry_element.orm_path)
+
+    def get_main_geometry_value(self, instance: models.Model) -> GEOSGeometry | None:
+        """Efficiently retrieve the value for the main geometry element."""
+        if self.main_geometry_element is None:
+            return None
+        else:
+            return self._geometry_getter(instance)
+
+    @cached_property
+    def xpath_matches(self) -> list[XPathMatch]:
+        """Resolve which elements the property names point to"""
+        if not self.property_names:
+            raise RuntimeError("This method is only useful for propertyname projections.")
+
+        return [
+            self.feature_type.resolve_element(property_name.xpath, property_name.xpath_ns_aliases)
+            for property_name in self.property_names
+        ] + self._extra_matches
+
+    @cached_property
+    def all_elements(self) -> list[XsdElement]:
+        """Return ALL elements of all levels to render."""
+        return self.xsd_root_elements + list(
+            itertools.chain.from_iterable(self.xsd_child_nodes.values())
+        )
+
+    @cached_property
+    def all_geometry_elements(self) -> list[GeometryXsdElement]:
+        """Tell which GML elements will be hit."""
+        return [e for e in self.all_elements if e.type.is_geometry]
+
+    @cached_property
+    def all_complex_elements(self) -> list[_XsdElement_WithComplexType]:
+        """Return ALL tree elements with a complex type, including child elements with a complex types."""
+        return list(self.xsd_child_nodes.keys())
+
+    @cached_property
+    def all_flattened_elements(self) -> list[XsdElement]:
+        """Shortcut to get ALL tree elements with a flattened model attribute"""
+        if not self.property_names:
+            return self.feature_type.xsd_type.flattened_elements
+        else:
+            return [e for e in self.all_elements if e.is_flattened]
+
+    @cached_property
+    def has_bounded_by(self) -> bool:
+        """Tell whether the <gml:boundedBy> element is included for rendering."""
+        return any(e.type is XsdTypes.gmlBoundingShapeType for e in self.xsd_root_elements)
+
+    @cached_property
+    def main_geometry_element(self) -> GeometryXsdElement | None:
+        """Return the field used to describe the geometry of the feature.
+        When the projection excludes the geometry, ``None`` is returned.
+        """
+        geo_element = self.feature_type.main_geometry_element
+        if self.property_names and geo_element not in self.all_elements:
+            return None
+
+        return geo_element
+
+    @cached_property
+    def geometry_elements(self) -> list[GeometryXsdElement]:
+        """Tell which GML elements will be hit at the root-level."""
+        return [
+            e
+            for e in self.xsd_root_elements
+            if e.type.is_geometry and e.type is not XsdTypes.gmlBoundingShapeType
+        ]
+
+    @cached_property
+    def property_value_node(self) -> XsdNode:
+        """For GetPropertyValue, resolve the element that is rendered."""
+        if self.value_reference is None:
+            raise RuntimeError("This method is only useful for GetPropertyValue calls.")
+        return (
+            self.feature_types[0]
+            .resolve_element(self.value_reference.xpath, self.value_reference.xpath_ns_aliases)
+            .child
+        )
+
+    @cached_property
+    def orm_relations(self) -> list[FeatureRelation]:
+        """Tell which fields will be retrieved from related fields.
+
+        This gives an object layout based on the XSD elements,
+        that can be used for prefetching data.
+        """
+        related_models: dict[str, type[models.Model]] = {}
+        fields: dict[str, set[XsdElement]] = defaultdict(set)
+        elements = defaultdict(list)
+
+        # Check all elements that render as "dotted" flattened relation
+        for xsd_element in self.all_flattened_elements:
+            if xsd_element.source is not None:
+                # Split "relation.field" notation into path, and take the field as child attribute.
+                obj_path, field = xsd_element.orm_relation
+                elements[obj_path].append(xsd_element)
+                fields[obj_path].add(xsd_element)
+                # field is already on relation:
+                related_models[obj_path] = xsd_element.source.model
+
+        # Check all elements that render as "nested" complex type:
+        for xsd_element in self.all_complex_elements:
+            # The complex element itself points to the root of the path,
+            # all sub elements become the child attributes.
+            obj_path = xsd_element.orm_path
+            elements[obj_path].append(xsd_element)
+            fields[obj_path] = {
+                f
+                for f in self.xsd_child_nodes[xsd_element]
+                if not f.is_many or f.is_array  # exclude M2M, but include ArrayField
+            }
+            if xsd_element.source:
+                # field references a related object:
+                related_models[obj_path] = xsd_element.source.related_model
+
+        return [
+            FeatureRelation(
+                orm_path=obj_path,
+                sub_fields=sub_fields,
+                related_model=related_models.get(obj_path),
+                xsd_elements=elements[obj_path],
+            )
+            for obj_path, sub_fields in fields.items()
+        ]
+
+    @cached_property
+    def only_fields(self) -> list[str]:
+        """Tell which fields to limit the queryset to.
+        This excludes M2M fields because those are not part of the local model data.
+        """
+        if self.property_names is not None:
+            return [
+                # TODO: While ORM rel__child paths can be passed to .only(),
+                # these may not be accurately applied to foreign keys yet.
+                # Also, this is bypassed by our generated Prefetch() objects.
+                xpath_match.orm_path
+                for xpath_match in self.xpath_matches
+                if not xpath_match.is_many or xpath_match.child.is_array
+            ]
+        else:
+            # Also limit the queryset to the actual fields that are shown.
+            # No need to request more data
+            return [
+                f.orm_field
+                for f in self.feature_type.xsd_type.elements
+                if not f.is_many or f.is_array  # avoid M2M fields for .only(), but keep ArrayField
+            ]
+
+
+@dataclass
+class FeatureRelation:
+    """Tell which related fields are queried by the feature.
+    Each dict holds an ORM-path, with the relevant sub-elements.
+    """
+
+    #: The ORM path that is queried for this particular relation
+    orm_path: str
+    #: The fields that will be retrieved for that path (limited by the projection)
+    sub_fields: set[XsdElement]
+    #: The model that is accessed for this relation (if set)
+    related_model: type[models.Model] | None
+    #: The source elements that access this relation. Could be multiple for flattened relations.
+    xsd_elements: list[XsdElement]
+
+    @cached_property
+    def _local_model_field_names(self) -> list[str]:
+        """Tell which local fields of the model will be accessed by this feature."""
+        return [
+            model_field.name
+            for field in self.sub_fields
+            if not (model_field := field.source).many_to_many and not model_field.one_to_many
+        ] + self._local_backlink_field_names
+
+    @property
+    def _local_backlink_field_names(self) -> list[str]:
+        # When this relation is retrieved through a ManyToOneRel (reverse FK),
+        # the prefetch_related() also needs to have the original foreign key
+        # in order to link all prefetches to the proper parent instance.
+        return [
+            xsd_element.source.field.name
+            for xsd_element in self.xsd_elements
+            if xsd_element.source is not None and xsd_element.source.one_to_many
+        ]
+
+    @property
+    def geometry_elements(self) -> list[GeometryXsdElement]:
+        """Tell which geometry elements this relation will access."""
+        return [f for f in self.sub_fields if f.type.is_geometry]
+
+
+def _partition(predicate, items: list) -> tuple[list, set]:
+    """Semi-efficient way to split a list into items that match/don't match the condition."""
+    # more_itertools.partition() is faster, but that can be neglected with a short list.
+    return list(itertools.filterfalse(predicate, items)), set(filter(predicate, items))
+
+
+def _clear_cached_properties(object):
+    """Remove the caches from the cached_property decorator on an object."""
+    cls = object.__class__
+    for property_name in list(object.__dict__):
+        if (prop := getattr(cls, property_name, None)) is not None and isinstance(
+            prop, cached_property
+        ):
+            del object.__dict__[property_name]

gisserver/static/gisserver/index.css

@@ -1,4 +1,15 @@
-tbody th { text-align: left; }
+.meta-page {
+  font-family: Arial, sans-serif;
+  line-height: 1.5;
+  margin: 0 2rem 4rem 2rem;
+}
+
+.meta-page h2 { margin: 2rem 0 0.5rem 0; }
+.meta-page h3 { margin: 1rem 0 0.5rem 0; }
+.meta-page p { margin: 0 0 1rem 0; }
+
+tbody th { text-align: left; padding-right: 2rem; }
+tbody td { padding-right: 2rem; }
 .complex-level-1 th { padding-left: 16px; }
 .complex-level-2 th { padding-left: 32px; }
 .complex-level-3 th { padding-left: 48px; }

gisserver/templates/gisserver/index.html

@@ -6,7 +6,7 @@
   {% block link %}<link rel="stylesheet" type="text/css" href="{% static 'gisserver/index.css' %}">{% endblock %}
   {% block extrahead %}{% endblock %}
 </head>
-<body>
+<body class="{% block body-class %}meta-page{% endblock %}">
   <header>
     {% block header %}{% include "gisserver/service_description.html" %}{% endblock %}
   </header>

gisserver/templates/gisserver/service_description.html

@@ -3,10 +3,10 @@
 {% if service_description.abstract %}{{ service_description.abstract|linebreaks }}{% endif %}
 
 {% if service_description.keywords %}
-<p>{% trans "Keywords" %}: {% for keyword in service_description.keywords %}{{ keyword }}{% if not forloop.last %}, {% endif %}{% endfor %}</p>
+<p>{% trans "Keywords" %}: {{ service_description.keywords|join:", " }}</p>
 {% endif %}
 {% if service_description.provider_name %}
-  {% trans "Provider" %}: {% if service_description.provider_site %}<a href="{{ service_description.provider_site }}">{% endif %}{{ service_description.provider_name }}{% if service_description.provider_site %}</a>{% endif %}
+  <p>{% trans "Provider" %}: {% if service_description.provider_site %}<a href="{{ service_description.provider_site }}">{% endif %}{{ service_description.provider_name }}{% if service_description.provider_site %}</a></p>{% endif %}
   {% if service_description.contact_person %}<p>{% trans "Contact" %}: {{ service_description.contact_person }}</p>{% endif %}
 {% endif %}
 {% if connect_url %}