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

gisserver/views.py

@@ -2,29 +2,43 @@
 
 from __future__ import annotations
 
+import logging
 import re
-from urllib.parse import urlencode
+from urllib.parse import unquote_plus, urlencode
 
 from django.core.exceptions import ImproperlyConfigured, SuspiciousOperation
 from django.core.exceptions import PermissionDenied as Django_PermissionDenied
 from django.shortcuts import render
 from django.views import View
+from django.views.decorators.csrf import csrf_exempt
 
 from gisserver import conf
 from gisserver.exceptions import (
+    ExternalParsingError,
     InvalidParameterValue,
-    MissingParameterValue,
     OperationNotSupported,
+    OperationParsingFailed,
+    OperationProcessingFailed,
     OWSException,
     PermissionDenied,
+    XmlElementNotSupported,
 )
 from gisserver.features import FeatureType, ServiceDescription
 from gisserver.operations import base, wfs20
+from gisserver.parsers.ows import (
+    BaseOwsRequest,
+    KVPRequest,
+    resolve_kvp_parser_class,
+    resolve_xml_parser_class,
+)
+from gisserver.parsers.xml import parse_xml_from_string, split_ns
+
+logger = logging.getLogger(__name__)
 
 SAFE_VERSION = re.compile(r"\A[0-9.]+\Z")
 
 
-class GISView(View):
+class OWSView(View):
     """The base logic to implement OGC view like WFS.
 
     Each subclass defines 'accept_operations' with the desired RPC operations.
@@ -33,6 +47,9 @@ class GISView(View):
     #: Define the namespace to use in the XML
     xml_namespace = "http://example.org/gisserver"
 
+    #: Define namespace aliases to use, default is ``{"app": self.xml_namespace}``.
+    xml_namespace_aliases = None
+
     #: Default version to use
     version = "2.0.0"
 
@@ -54,6 +71,10 @@ class GISView(View):
     #: Whether to render GET HTML pages
     use_html_templates = True
 
+    #: The OWS request, which contains the complete parsed request.
+    ows_request: BaseOwsRequest = None
+
+    @csrf_exempt
     def dispatch(self, request, *args, **kwargs):
         """Render proper XML errors for exceptions on all request types."""
         try:
@@ -78,30 +99,114 @@ class GISView(View):
         else:
             return None
 
+    @classmethod
+    def get_xml_namespace_aliases(cls) -> dict[str, str]:
+        """Provide all namespaces aliases with a namespace.
+        This is most useful for parsing input.
+        The default is: ``{"app": cls.xml_namespace}``.
+        """
+        return cls.xml_namespace_aliases or {"app": cls.xml_namespace}
+
+    @classmethod
+    def get_xml_namespaces_to_prefixes(cls) -> dict[str, str]:
+        """Provide a mapping from namespace to prefix.
+        This is most useful for rendering output.
+        The default is: ``{cls.xml_namespace: "app"}``.
+        """
+        return {
+            xml_namespace: prefix
+            for prefix, xml_namespace in cls.get_xml_namespace_aliases().items()
+        }
+
     def get(self, request, *args, **kwargs):
         """Entry point to handle HTTP GET requests.
 
         This parses the 'SERVICE' and 'REQUEST' parameters,
-        to call the proper operation.
+        to call the proper :class:`~gisserver.operations.base.WFSOperation`.
 
         All query parameters are handled as case-insensitive.
         """
-        # Convert to WFS key-value-pair format.
-        self.KVP = {key.upper(): value for key, value in request.GET.items()}
+        # Parse GET parameters in Key-Value-Pair syntax format.
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(
+                "Parsing GET parameters:\n%s",
+                unquote_plus(
+                    request.META["QUERY_STRING"].replace("\n&", "\n").replace("&", "\n")
+                ).rstrip(),
+            )
+        self.kvp = kvp = KVPRequest(request.GET, ns_aliases=self.get_xml_namespace_aliases())
+
+        # Get service (only raises error when value is missing and "default" parameter is not given)
+        defaults = {"default": self.default_service} if self.default_service else {}
+        service = kvp.get_str("service", **defaults).upper()
 
         # Perform early version parsing. The detailed validation happens by the operation
         # Parameter objects, but by performing an early check, templates can use that version.
-        version = self.KVP.get("VERSION")
-        if version and version in self.accept_versions:
-            self.set_version(version)
+        version = kvp.get_str("version", default=None)
+        self.set_version(service, version)
 
         # Allow for a user-friendly opening page (hence the version check above)
         if self.use_html_templates and self.is_index_request():
-            return self.render_index()
+            return self.render_index(service)
+
+        # Find the registered operation that handles the request
+        operation = kvp.get_str("request")
+        wfs_operation_cls = self.get_operation_class(service, operation)
+
+        # Parse the request syntax
+        request_cls = wfs_operation_cls.parser_class or resolve_kvp_parser_class(kvp)
+        self.ows_request = request_cls.from_kvp_request(kvp)
+
+        # Process the request!
+        return self.call_operation(wfs_operation_cls)
 
-        # Normal WFS
-        wfs_method_cls = self.get_operation_class()
-        return self.call_operation(wfs_method_cls)
+    def post(self, request, *args, **kwargs):
+        """Entry point to handle HTTP POST requests.
+
+        This parses the XML to get the correct service and operation,
+        to call the proper :class:`~gisserver.operations.base.WFSOperation`.
+        """
+        # Parse the XML body
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("Parsing POST:\n%s", request.body.decode().rstrip())
+        try:
+            root = parse_xml_from_string(
+                request.body, extra_ns_aliases=self.get_xml_namespace_aliases()
+            )
+        except ExternalParsingError as e:
+            raise OperationParsingFailed(f"Unable to parse XML: {e}") from e
+
+        # Find the registered operation that handles the request
+        service = (
+            root.attrib.get("service", self.default_service)
+            if self.default_service
+            else root.get_str_attribute("service")
+        )
+
+        # Perform early version check. version can be omitted for GetCapabilities
+        self.set_version(service, root.attrib.get("version"))
+
+        # Find the registered operation that handles the request
+        namespace, operation = split_ns(root.tag)
+        wfs_operation_cls = self.get_operation_class(service, operation)
+
+        try:
+            # Parse the request syntax
+            request_cls = wfs_operation_cls.parser_class or resolve_xml_parser_class(root)
+            self.ows_request = request_cls.from_xml(root)
+
+            # Process the request!
+            return self.call_operation(wfs_operation_cls)
+        except XmlElementNotSupported as e:
+            # Unknown XML element, e.g. wrong namespace.
+            raise OperationNotSupported(str(e), locator=root.attrib.get("handle")) from e
+        except (OperationParsingFailed, OperationProcessingFailed) as e:
+            # The WFS spec dictates that these exceptions
+            # (and ResponseCacheExpired, CannotLockAllFeatures, FeaturesNotLocked which we don't raise)
+            # should report the 'handle' in the 'locator' argument of the exception when it was provided.
+            if self.ows_request.handle:
+                e.locator = self.ows_request.handle
+            raise
 
     def is_index_request(self):
         """Tell whether to index page should be shown."""
@@ -109,22 +214,29 @@ class GISView(View):
         # (misspelled?) parameters on the query string, this is considered to be an index page.
         # Minimal request has 2 parameters (SERVICE=WFS&REQUEST=GetCapabilities).
         # Some servers also allow a default of SERVICE, thus needing even less.
-        return len(self.KVP) < 2 and {
-            "REQUEST",
-            "SERVICE",
-            "VERSION",
-            "ACCEPTVERSIONS",
-        }.isdisjoint(self.KVP.keys())
-
-    def render_index(self):
+        return (
+            self.request.method == "GET"
+            and len(self.request.GET) < 2
+            and {
+                "REQUEST",
+                "SERVICE",
+                "VERSION",
+                "ACCEPTVERSIONS",
+            }.isdisjoint(key.upper() for key in self.request.GET)
+        )
+
+    def render_index(self, service: str | None = None):
         """Render the index page."""
         # Not using the whole TemplateResponseMixin config with configurable parameters.
         # If this really needs more configuration, overriding is likely just as easy.
-        return render(self.request, self.get_index_template_names(), self.get_index_context_data())
+        return render(
+            self.request,
+            self.get_index_template_names(service),
+            self.get_index_context_data(service=service),
+        )
 
-    def get_index_context_data(self, **kwargs):
+    def get_index_context_data(self, service: str | None = None, **kwargs):
         """Provide the context data for the index page."""
-        service = self.KVP.get("SERVICE", self.default_service)
         root_url = self.request.build_absolute_uri()
 
         # Allow passing extra vendor parameters to the links generated in the template
@@ -138,6 +250,7 @@ class GISView(View):
 
         return {
             "view": self,
+            "xml_namespaces": self.get_xml_namespaces_to_prefixes(),
             "service": service,
             "root_url": root_url,
             "base_query": base_query,
@@ -149,16 +262,11 @@ class GISView(View):
             **kwargs,
         }
 
-    def get_index_template_names(self):
+    def get_index_template_names(self, service: str | None = None):
         """Get the index page template name.
         If no template is configured, some reasonable defaults are selected.
         """
-        raw_service = self.KVP.get("SERVICE", self.default_service)
-        if raw_service and raw_service in self.accept_operations:
-            service = raw_service.lower()
-        else:
-            service = "default"
-
+        service = service.lower() if service and service in self.accept_operations else "default"
         if self.index_template_name:
             # Allow the same substitutions for a manually configured template.
             return [self.index_template_name.format(service=service, version=self.version)]
@@ -169,60 +277,65 @@ class GISView(View):
                 "gisserver/index.html",
             ]
 
-    def get_operation_class(self) -> type[base.WFSMethod]:
+    def get_operation_class(self, service: str, request: str) -> type[base.WFSOperation]:
         """Resolve the method that the client wants to call."""
         if not self.accept_operations:
             raise ImproperlyConfigured("View has no operations")
 
-        # The service is always WFS
-        service = self._get_required_arg("SERVICE", self.default_service).upper()
         try:
-            operations = self.accept_operations[service]
+            operations = self.accept_operations[service.upper()]
         except KeyError:
             allowed = ", ".join(sorted(self.accept_operations.keys()))
             raise InvalidParameterValue(
-                f"'{service}' is an invalid service, supported are: {allowed}.",
+                f"'{service}' is not supported, available are: {allowed}.",
                 locator="service",
             ) from None
 
         # Resolve the operation
         # In mapserver, the operation name is case-insensitive.
-        operation = self._get_required_arg("REQUEST").upper()
         uc_methods = {name.upper(): method for name, method in operations.items()}
-
         try:
-            return uc_methods[operation]
+            return uc_methods[request.upper()]
         except KeyError:
             allowed = ", ".join(operations.keys())
             raise OperationNotSupported(
-                f"'{operation.lower()}' is not implemented, supported are: {allowed}.",
+                f"'{request}' is not implemented, supported are: {allowed}.",
                 locator="request",
             ) from None
 
-    def call_operation(self, wfs_method_cls: type[base.WFSMethod]):
+    def call_operation(self, wfs_operation_cls: type[base.WFSOperation]):
         """Call the resolved method."""
-        wfs_method = wfs_method_cls(self)
-        param_values = wfs_method.parse_request(self.KVP)
-        return wfs_method(**param_values)  # goes into __call__()
+        self.request.ows_request = self.ows_request  # for check_permissions()
 
-    def _get_required_arg(self, argname, default=None):
-        try:
-            return self.KVP[argname]
-        except KeyError:
-            if default is not None:
-                return default
-            raise MissingParameterValue(locator=argname.lower()) from None
+        wfs_operation = wfs_operation_cls(self, self.ows_request)
+        wfs_operation.validate_request(self.ows_request)
+        return wfs_operation.process_request(self.ows_request)
 
-    def get_service_description(self, service: str) -> ServiceDescription:
+    def get_service_description(self, service: str | None = None) -> ServiceDescription:
         """Provide the (dynamically generated) service description."""
         return self.service_description or ServiceDescription(title="Unnamed")
 
-    def set_version(self, version):
+    def set_version(self, service: str, version: str | None):
         """Enforce a particular version based on the request."""
+        if service.upper() not in self.accept_operations:
+            allowed = ", ".join(sorted(self.accept_operations.keys()))
+            raise InvalidParameterValue(
+                f"'{service}' is not supported, available are: {allowed}.",
+                locator="service",
+            ) from None
+
+        if not version:
+            return
+
         if not SAFE_VERSION.match(version):
             # Make really sure we didn't mess things up, as this causes file includes.
             raise SuspiciousOperation("Invalid/insecure version number parsed")
 
+        if version not in self.accept_versions:
+            raise InvalidParameterValue(
+                f"This server does not support {service} version {version}.", locator="version"
+            )
+
         # Enforce the requested version
         self.version = version
 
@@ -232,7 +345,7 @@ class GISView(View):
         return self.request.build_absolute_uri(self.request.path)
 
 
-class WFSView(GISView):
+class WFSView(OWSView):
     """A view for a single WFS server.
 
     This view exposes multiple dataset,
@@ -246,6 +359,7 @@ class WFSView(GISView):
     max_page_size = conf.GISSERVER_DEFAULT_MAX_PAGE_SIZE
 
     #: Define the features (=tables) in this dataset.
+    #: For dynamic per-request logic, consider overwriting :meth:`get_feature_types` instead.
     feature_types: list[FeatureType] = []
 
     #: Internal configuration of all available RPC calls.
@@ -270,7 +384,7 @@ class WFSView(GISView):
         "ImplementsTransactionalWFS": False,  # only reads
         "ImplementsLockingWFS": False,  # only basic WFS
         "KVPEncoding": True,  # HTTP GET support
-        "XMLEncoding": False,  # HTTP POST requests
+        "XMLEncoding": True,  # HTTP POST requests
         "SOAPEncoding": False,  # no SOAP requests
         "ImplementsInheritance": False,
         "ImplementsRemoteResolve": False,
@@ -305,20 +419,71 @@ class WFSView(GISView):
     }
 
     def get_feature_types(self) -> list[FeatureType]:
-        """Return all available feature types this server exposes"""
-        return self.feature_types
+        """Return all available feature types this server exposes.
 
-    def get_index_context_data(self, **kwargs):
-        """Add WFS specific metadata"""
-        wfs_output_formats = self.accept_operations["WFS"]["GetFeature"].output_formats
+        This method may be overwritten to provide feature types dynamically,
+        for example to give them different elements based on user permissions.
+        """
+        return self.feature_types
 
+    def get_bound_feature_types(self) -> list[FeatureType]:
+        """Internal logic wrapping the FeatureType definitions provided by the developer.
+        This binds the XML namespace information from this view to the declared types.
+        """
+        feature_types = self.get_feature_types()
+        for feature_type in feature_types:
+            # Make sure the feature type can advertise itself with an XML namespace.
+            feature_type.bind_namespace(default_xml_namespace=self.xml_namespace)
+        return feature_types
+
+    def get_index_context_data(self, **kwargs) -> dict:
+        """Get the context data for the index template"""
         context = super().get_index_context_data(**kwargs)
         context.update(
             {
-                "wfs_features": self.get_feature_types(),
-                "wfs_output_formats": wfs_output_formats,
+                "GISSERVER_SUPPORTED_CRS_ONLY": conf.GISSERVER_SUPPORTED_CRS_ONLY,
+                "wfs_features": self.get_bound_feature_types(),
+                "wfs_output_formats": self._get_wfs_output_formats(),
                 "wfs_filter_capabilities": self.wfs_filter_capabilities,
                 "wfs_service_constraints": self.wfs_service_constraints,
             }
         )
         return context
+
+    def _get_wfs_output_formats(self) -> list[base.OutputFormat]:
+        """Find the output formats of the ``GetFeature`` operation for the HTML index."""
+        get_feature_operation = self.accept_operations["WFS"]["GetFeature"]
+        operation = get_feature_operation(self, ows_request=None)
+
+        # Get output formats, remove duplicates (e.g. GeoJSON/geojson alias)
+        wfs_output_formats = []
+        seen = set()
+        for output_format in operation.get_output_formats():
+            if output_format.identifier not in seen:
+                wfs_output_formats.append(output_format)
+            seen.add(output_format.identifier)
+        return wfs_output_formats
+
+    def get_xml_schema_url(self, feature_types: list[FeatureType]) -> str:
+        """Return the XML schema URL for the given feature types.
+        This is used in the GML output rendering.
+        """
+        app_namespaces = self.get_xml_namespaces_to_prefixes()
+        type_names = ",".join(
+            f"{app_namespaces[ft.xml_namespace]}:{ft.name}" for ft in feature_types
+        )
+        return (
+            f"{self.server_url}?SERVICE=WFS&VERSION=2.0.0"
+            f"&REQUEST=DescribeFeatureType&TYPENAMES={type_names}"
+        )
+
+    def check_permissions(self, feature_type: FeatureType):
+        """Hook that allows subclasses to reject access for datasets.
+        It may raise a Django PermissionDenied error.
+
+        This can access: ``self.request`` (the Django HTTPRequest) and ``self.ows_request``.
+        The latter contains a parsed request object
+        from the :mod:`gisserver.parsers.wfs20` package,
+        such as the parsed :class:`~gisserver.parsers.wfs20.GetFeature`
+        or :class:`~gisserver.parsers.wfs20.GetPropertyValue` request.
+        """

django_gisserver-1.5.0.dist-info/RECORD

@@ -1,54 +0,0 @@
-gisserver/__init__.py,sha256=XtaIlx7Gik8RqIFDc1G0JAUfcmeNyTWjev1E1Oym_ms,40
-gisserver/conf.py,sha256=3LSfeDRTdJCLuopAOD14Y5m2iPhovreIaNI9zbaukpo,2343
-gisserver/db.py,sha256=-d6VQRkRWMSWKkA_6cVWhLzSI1cKmRoVktqA6hVwvuM,4928
-gisserver/exceptions.py,sha256=wRsiKWhZtA8NmfMNncRtMeFgWDMdOWRp9Ey96iFAwMI,5194
-gisserver/features.py,sha256=b3hEDs90xwEsANcRgipekZZrp4ucxRWwGeUutk2gRTw,31821
-gisserver/geometries.py,sha256=HLZ3d8E5M2sfs2Kzz_GE3pZdynn-rYXPpuU9GVh0vsg,12398
-gisserver/types.py,sha256=bsl3PezhGcHpUAtuV4AhdBmFLmtZZpDCT_HqpdVyLtM,36936
-gisserver/views.py,sha256=xMHKezn4F1xZ2r78l9IzUlL5M3qZ78fjRJJtSzA8-Ww,12809
-gisserver/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gisserver/operations/base.py,sha256=Ls5i6ulMJqyhqu6o969rJ-mezW-T6OW5mr8oZ3BTBH8,17222
-gisserver/operations/wfs20.py,sha256=bQeMJ4T6AisSBMABYa3li1u53w0zUxs02qBwjS4QbOw,18742
-gisserver/output/__init__.py,sha256=C6hXIVIxBd2o_1Y7VhIU9vCg7pswI2tXsd74wgMdU4o,2134
-gisserver/output/base.py,sha256=GygubFyhPO33fQw3jIuOerEH8yjbk0DJ6NhQdFkT7-g,8645
-gisserver/output/csv.py,sha256=Mm7zYzUs9ffw9fqcKY9NT7qbMX-MzSFnqBg5I1wdRU0,6459
-gisserver/output/geojson.py,sha256=bhRtNdMi1tMcSFBxDTNL8oysAMVhoolctKjZhxIncN8,11297
-gisserver/output/gml32.py,sha256=KbhcBBVp4sEhvKs5e6fP4_GKKL6Kr2yyYaDLWePBQxs,31293
-gisserver/output/results.py,sha256=VD-fJgWrMTwGaEGG_BSVhDv_m60dldBY6yAcTpRICT4,13949
-gisserver/output/utils.py,sha256=FIlkHymA43RLZAfB6-trM3_IQKbIVb_4OUp5fxRbVGY,7379
-gisserver/output/xmlschema.py,sha256=TdTMyP2_r98wkeffWAwrfm3l9XAmivu1KcYWNpgQKR4,4578
-gisserver/parsers/__init__.py,sha256=g72D8EtR-QkhcemzY5-Qty-nhHPKza83Sz3KZm8bfq0,290
-gisserver/parsers/base.py,sha256=9DE73wMphp7At3mGW0xwGU_TWPm55x8JEh4odpdRhlo,4833
-gisserver/parsers/tags.py,sha256=NyJhbt-U2zTewfhghH4LRslTaDK2UOq9Vgk83pWfJh0,3553
-gisserver/parsers/values.py,sha256=ypNPl4HduiVzexsL59ukZntlwXk5gHuSvQO6yhLeXD4,1016
-gisserver/parsers/fes20/__init__.py,sha256=72RuFxAQp9hW0pgFUDyfQ0WsStNNk6J_y3NH-zYaPOA,1140
-gisserver/parsers/fes20/expressions.py,sha256=A1-8JsGahXJPWLuTSVNAf0oSuyLfDMnFKM7viIt35Y8,9573
-gisserver/parsers/fes20/filters.py,sha256=HdWguZvAT2L4Xm-bNa4XPh7MEymqTB6fo8r47Z-Bjuw,3511
-gisserver/parsers/fes20/functions.py,sha256=mutPlbjOlg6R-9nNe8goaNdsAlZPkuckYlhMsQyp6NE,8723
-gisserver/parsers/fes20/identifiers.py,sha256=vcPrMYcsemSlB9ziSUdVulhoI5PGFAh8vqeADBCWd60,2864
-gisserver/parsers/fes20/operators.py,sha256=oQezU553Mts1DoExlH7_U29XXXdk6V84ihlBOozRzLg,23360
-gisserver/parsers/fes20/query.py,sha256=_OxElAgeo34-00pNY5Apc6TSUKokSG9VWSMmIplN7AA,10638
-gisserver/parsers/fes20/sorting.py,sha256=Uj8gsbBXumihWkrcj_pRPscwZAScUJSngAyjKri-Z8Y,2184
-gisserver/parsers/gml/__init__.py,sha256=lNK0SXWkmTKdeJD9xdK6B-N-Y7wwGL4NRBI3dzoJDNI,1463
-gisserver/parsers/gml/base.py,sha256=xWC5FrJyMjq7h5zmKwEvtRF0-CGVbCtvnO8Isvnf4mE,1065
-gisserver/parsers/gml/geometries.py,sha256=cgV3WogA7LyC_H_NF7dGoGLvLdQRACG6AlThRkX_jhU,3171
-gisserver/queries/__init__.py,sha256=yntEYRfaZ1Yjnr8lMvJt9Erh31WktikIf1af4TTuX74,1000
-gisserver/queries/adhoc.py,sha256=Hhcxwt5C2OHqtLc-3QUqx8MZEnhoqkKWjBp56e6aljc,7428
-gisserver/queries/base.py,sha256=EVJiwcLBjxGXJ8k012gGEiZ1q_gQZokSwdMl4H1SPus,7857
-gisserver/queries/projection.py,sha256=KEz9UcZGVkYq7XTm_5nx8w5TnbSqht7rOGEuTGeJwm8,9922
-gisserver/queries/stored.py,sha256=G258R9HVX3OooM5mhQF_N_JrFHLjM2y5iusrzPcN9TU,7125
-gisserver/static/gisserver/index.css,sha256=fiQuCMuiWUhhrNQD6bbUJaX5vH5OpG9qgPdELPB8cpI,163
-gisserver/templates/gisserver/index.html,sha256=yliku8jDqAOcenkbe1YnvJBnuS13MvzzsoDV8sQZ3GM,866
-gisserver/templates/gisserver/service_description.html,sha256=3EHLnQx27_nTDZFD2RH6E10EWnTN90s1DGuEj9PeBrg,993
-gisserver/templates/gisserver/wfs/feature_field.html,sha256=H5LsTAxGVGQqEpOZdEUTszQmFAZSpB9ggRJUsTdjYnw,538
-gisserver/templates/gisserver/wfs/feature_type.html,sha256=pIfa1cMsTlNIrzNiEOaq9LjzzF7_vZ9C7eN6KDBLOHE,788
-gisserver/templates/gisserver/wfs/2.0.0/describe_stored_queries.xml,sha256=4Hxw1kCnxfWXTVPbHf8IW9_qiSeIEtnxHK6z6TS3-zA,1041
-gisserver/templates/gisserver/wfs/2.0.0/get_capabilities.xml,sha256=Ej6ZXf-nGiPjiKdhNK5vAsX2iiiS12knjD0VaSzSltM,8717
-gisserver/templates/gisserver/wfs/2.0.0/list_stored_queries.xml,sha256=CIBVQrKXmGMQ6BKbX4_0ru4lXtWnW5EIgHUbIi1V0Vc,636
-gisserver/templatetags/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gisserver/templatetags/gisserver_tags.py,sha256=RFGqEj-EQi9FrJiFJ7HHAQqlU4fDKVKTtZrPNwURXgA,204
-django_gisserver-1.5.0.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-django_gisserver-1.5.0.dist-info/METADATA,sha256=IWlSvP8d_4wsCVq4NWAE0T7Q8QZGqFVMvWUyLss85aY,5859
-django_gisserver-1.5.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-django_gisserver-1.5.0.dist-info/top_level.txt,sha256=8zFCEMmkpixE4TPiOAlxSq3PD2EXvAeFKwG4yZoIIOQ,10
-django_gisserver-1.5.0.dist-info/RECORD,,

gisserver/parsers/base.py

@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from xml.etree.ElementTree import Element, QName
-
-from gisserver.exceptions import ExternalParsingError
-
-from .tags import split_ns
-
-
-class TagNameEnum(Enum):
-    """An enumeration of tag names.
-
-    All enumerations that represent tag names inherit from this.
-    Each member name should be exactly the XML tag that it refers to.
-    """
-
-    @classmethod
-    def from_xml(cls, element: Element):
-        """Cast the element tag name into the enum member"""
-        ns, localname = split_ns(element.tag)
-        return cls[localname]
-
-    @classmethod
-    def _missing_(cls, value):
-        raise NotImplementedError(f"<{value}> is not registered as valid {cls.__name__}")
-
-    def __repr__(self):
-        # Make repr(filter) easier to copy-paste
-        return f"{self.__class__.__name__}.{self.name}"
-
-
-class BaseNode:
-    """The base node for all classes that represent an XML tag."""
-
-    xml_ns = None
-    xml_tags = []
-
-    def __init_subclass__(cls):
-        cls.xml_tags = []
-
-    @classmethod
-    def from_xml(cls, element: Element):
-        raise NotImplementedError(
-            f"{cls.__name__}.from_xml() is not implemented to parse <{element.tag}>"
-        )
-
-    @classmethod
-    def from_child_xml(cls, element: Element) -> BaseNode:
-        """By default, the node attempts to locate a child-class from the registry.
-        The individual tags should override `from_xml()` to return their own type.
-        """
-        return tag_registry.from_child_xml(element, allowed_types=(cls,))
-
-
-class TagRegistry:
-    """Registration of all classes that can parse XML nodes.
-
-    The same class can be registered multiple times for different tag names.
-    """
-
-    parsers: dict[str, type[BaseNode]]
-
-    def __init__(self):
-        self.parsers = {}
-
-    def register(self, name=None, namespace=None, hidden=False):
-        """Decorator to register a class as XML node parser.
-
-        This registers the decorated class as the designated parser
-        for a specific XML tag.
-
-        Usage:
-
-            @dataclass
-            @tag_registry.register()
-            class SomeXmlTag(BaseNode):
-                xml_ns = FES
-
-                @classmethod
-                def from_xml(cls, element: Element):
-                    return cls(
-                        ...
-                    )
-
-        """
-
-        def _dec(sub_class: type[BaseNode]) -> type[BaseNode]:
-            if sub_class.xml_ns is None:
-                raise RuntimeError(f"{sub_class.__name__}.xml_ns should be set")
-
-            localname = name or sub_class.__name__
-            qname = QName(namespace or sub_class.xml_ns, localname)
-
-            self.parsers[qname] = sub_class  # Track this parser to resolve the tag.
-            if not hidden:
-                sub_class.xml_tags.append(name)  # Allow fetching all names later
-            return sub_class  # allow decorator usage
-
-        return _dec
-
-    def register_names(self, names: type[TagNameEnum], namespace=None):
-        """Decorator to register the 'tag_class' as the
-        parser-backend for all member-names in this enum.
-        """
-
-        def _dec(sub_class: type[BaseNode]):
-            # Looping over _member_names_ will skip aliased items (like BBOX/Within)
-            for member_name in names.__members__:
-                self.register(name=member_name, namespace=namespace)(sub_class)
-            return sub_class
-
-        return _dec
-
-    def from_child_xml(self, element: Element, allowed_types=None) -> BaseNode:
-        """Convert the element into a Python class.
-
-        This locates the parser from the registered tag.
-        It's assumed that the tag has a "from_xml()" method too.
-        """
-        try:
-            real_cls = self.resolve_class(element.tag)
-        except ExternalParsingError as e:
-            if allowed_types:
-                # Show better exception message
-                types = ", ".join(c.__name__ for c in allowed_types)
-                raise ExternalParsingError(f"{e}, expected one of: {types}") from None
-
-            raise
-
-        # Check whether the resolved class is indeed a valid option here.
-        if allowed_types is not None and not issubclass(real_cls, allowed_types):
-            types = ", ".join(c.__name__ for c in allowed_types)
-            raise ExternalParsingError(
-                f"Unexpected {real_cls.__name__} for <{element.tag}> node, "
-                f"expected one of: {types}"
-            )
-
-        return real_cls.from_xml(element)
-
-    def resolve_class(self, tag_name) -> type[BaseNode]:
-        # Resolve the dataclass using the tag name
-        try:
-            return self.parsers[tag_name]
-        except KeyError:
-            raise ExternalParsingError(f"Unsupported tag: <{tag_name}>") from None
-
-
-tag_registry = TagRegistry()