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

gisserver/views.py

@@ -2,30 +2,42 @@
 
 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.http import HttpResponse
 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,
 )
 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.
@@ -34,6 +46,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"
 
@@ -49,12 +64,16 @@ class GISView(View):
     #: Metadata of the service:
     service_description: ServiceDescription | None = None
 
-    #: Template to render a HTML welcome page for non-OGC requests.
+    #: Template to render an HTML welcome page for non-OGC requests.
     index_template_name = None
 
     #: 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:
@@ -70,25 +89,32 @@ class GISView(View):
         When nothing is returned, the exception is raised instead.
         """
         if isinstance(exc, Django_PermissionDenied):
-            exc = PermissionDenied("typeNames", text=str(exc) or None)
-            return HttpResponse(
-                exc.as_xml().encode("utf-8"),
-                content_type="text/xml; charset=utf-8",
-                status=exc.status_code,
-                reason=exc.reason,
-            )
+            exc = PermissionDenied(str(exc) or None, locator="typeNames")
+            return exc.as_response()
         elif isinstance(exc, OWSException):
             # Wrap our XML-based exception into a response.
             exc.version = self.version  # Use negotiated version
-            return HttpResponse(
-                exc.as_xml().encode("utf-8"),
-                content_type="text/xml; charset=utf-8",
-                status=exc.status_code,
-                reason=exc.reason,
-            )
+            return exc.as_response()
         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.
+        """
+        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.
+        """
+        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.
 
@@ -97,22 +123,78 @@ class GISView(View):
 
         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")),
+            )
+        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 an user-friendly opening page (hence the version check above)
+        # 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)
+
+    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 WFSMethod.
+        """
+        # 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")
+        )
+        operation = split_ns(root.tag)[1]
+        wfs_operation_cls = self.get_operation_class(service, operation)
 
-        # Normal WFS
-        wfs_method_cls = self.get_operation_class()
-        return self.call_operation(wfs_method_cls)
+        # Parse the request syntax
+        request_cls = wfs_operation_cls.parser_class or resolve_xml_parser_class(root)
+        try:
+            self.ows_request = request_cls.from_xml(root)
+            self.set_version(service, self.ows_request.version)
+
+            # Process the request!
+            return self.call_operation(wfs_operation_cls)
+        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."""
@@ -120,22 +202,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
@@ -149,6 +238,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,
@@ -160,16 +250,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)]
@@ -180,60 +265,58 @@ 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(
-                "service",
                 f"'{service}' is an invalid service, supported are: {allowed}.",
+                locator="service",
             ) from None
 
         # Resolve the operation
-        # In mapserver, the operation name is case insensitive.
-        operation = self._get_required_arg("REQUEST").upper()
+        # In mapserver, the operation name is case-insensitive.
         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(
-                "request",
-                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(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 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"{service} Server does not support VERSION {version}.", locator="version"
+            )
+
         # Enforce the requested version
         self.version = version
 
@@ -243,7 +326,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,
@@ -257,6 +340,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.
@@ -281,7 +365,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,
@@ -316,20 +400,67 @@ class WFSView(GISView):
     }
 
     def get_feature_types(self) -> list[FeatureType]:
-        """Return all available feature types this server exposes"""
+        """Return all available feature types this server exposes.
+
+        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):
         """Add WFS specific metadata"""
-        wfs_output_formats = self.accept_operations["WFS"]["GetFeature"].output_formats
+        get_feature_operation = self.accept_operations["WFS"]["GetFeature"]
+        operation = get_feature_operation(self, ows_request=None)
+
+        # Remove aliases
+        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)
 
         context = super().get_index_context_data(**kwargs)
         context.update(
             {
-                "wfs_features": self.get_feature_types(),
+                "wfs_features": self.get_bound_feature_types(),
                 "wfs_output_formats": wfs_output_formats,
                 "wfs_filter_capabilities": self.wfs_filter_capabilities,
                 "wfs_service_constraints": self.wfs_service_constraints,
             }
         )
         return context
+
+    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.4.1.dist-info/RECORD

@@ -1,53 +0,0 @@
-gisserver/__init__.py,sha256=ouhGKnkyYnTmywjuiv3RGvKgca9hYJc5FP0cJxrQDgo,40
-gisserver/conf.py,sha256=3LSfeDRTdJCLuopAOD14Y5m2iPhovreIaNI9zbaukpo,2343
-gisserver/db.py,sha256=iuj43NonqNdKkLrerdzTucy-Lu5NmqymuE0bkwR6XWs,5318
-gisserver/exceptions.py,sha256=TZVdmwKI90Ga-9l8A1H0u65V5yNvgg2TDgyN_LCQ2zI,4597
-gisserver/features.py,sha256=GFbi-ap4NjlJh2Ka6Ssh-OjgZClLzVZyBqYqmolAtfI,32171
-gisserver/geometries.py,sha256=VQVEFk0oRiqdxG28llb51aayf5m9cbyLljR3PrZfMTg,12400
-gisserver/types.py,sha256=vyHPkUXEADikTJfRq7Nodqt0BCo7YV91dNyZw6GIMO4,35087
-gisserver/views.py,sha256=A7TwUsG8NKdnjTbOXPbio1K-XRg6IIpy_xH__zwW8xI,13193
-gisserver/operations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gisserver/operations/base.py,sha256=tIEvQvFRRX2esfeP48EmcwB27-MkShtjl6A1v9TJASE,16827
-gisserver/operations/wfs20.py,sha256=lYkEq4DZYTSxNdwdZBAGOb7vtN5qMnwxOp8OD1G3jR4,18426
-gisserver/output/__init__.py,sha256=EVzgFN-PqKZKwbGVgWBUbIzGIXo69HSDMQ37szgr6cw,2097
-gisserver/output/base.py,sha256=NYyV78JgNDV7uUmnk6HNbbLTkt_N60YKPh2z1o-AuzM,7791
-gisserver/output/csv.py,sha256=7UKnyhFyAH1yeOh719Ov3SkzoLF1Zzlp_0-wxRDU9bI,6222
-gisserver/output/geojson.py,sha256=KB4w6DU_Dn7ZNDM5INDEtz7zhOAN75v03lUayPDzGPE,11296
-gisserver/output/gml32.py,sha256=kaTljrRKIlxIshiJTtzmsWWJExzQSL4hEX_Q1i17k_4,30496
-gisserver/output/results.py,sha256=HOmeSKLb0Tzsd9AamuXEPZyRmoXxHj7fKBqIbk1J5Co,13301
-gisserver/output/utils.py,sha256=VR8nOAv1obhfumQy77RnpJpE3FopzuIJrkfosBq16w4,6569
-gisserver/output/xmlschema.py,sha256=ltCglrQ4YXJ_dpMrkXb06dFfHc5a_nGog7fb-K25aeQ,4579
-gisserver/parsers/__init__.py,sha256=g72D8EtR-QkhcemzY5-Qty-nhHPKza83Sz3KZm8bfq0,290
-gisserver/parsers/base.py,sha256=eK32lw004v-lU82JihnH5LF-3wSh8M-L4JSayDt2gJM,4835
-gisserver/parsers/tags.py,sha256=NyJhbt-U2zTewfhghH4LRslTaDK2UOq9Vgk83pWfJh0,3553
-gisserver/parsers/values.py,sha256=ypNPl4HduiVzexsL59ukZntlwXk5gHuSvQO6yhLeXD4,1016
-gisserver/parsers/fes20/__init__.py,sha256=l8OutRicZ8E2cpyFtJj6wTFNArYoFaLiXABGyZYyKvQ,624
-gisserver/parsers/fes20/expressions.py,sha256=kXfIpOP94WOzvT3PZyIKrZSawQJZUPYyJ1TF5MoKsUQ,9694
-gisserver/parsers/fes20/filters.py,sha256=HdWguZvAT2L4Xm-bNa4XPh7MEymqTB6fo8r47Z-Bjuw,3511
-gisserver/parsers/fes20/functions.py,sha256=Qn72GI5qLqDSbREmsGUDiAPN2u1eo4c8AFttJMDnJX4,8724
-gisserver/parsers/fes20/identifiers.py,sha256=vcPrMYcsemSlB9ziSUdVulhoI5PGFAh8vqeADBCWd60,2864
-gisserver/parsers/fes20/operators.py,sha256=MVyoo2Hq45Lyqjh1cX9P_Zy9ARceCs28xDNL5ql_Yd0,23206
-gisserver/parsers/fes20/query.py,sha256=IQU0k4ZG-sAjWEWvSXw6H_wYODwtCMsF8RrbVdik4KE,10069
-gisserver/parsers/fes20/sorting.py,sha256=y0QJxFE0OC-GsaqrD0ZCI4CI16roUZrSW3fAG7BOKwA,2146
-gisserver/parsers/gml/__init__.py,sha256=lNK0SXWkmTKdeJD9xdK6B-N-Y7wwGL4NRBI3dzoJDNI,1463
-gisserver/parsers/gml/base.py,sha256=cMyXAoc1mhLp3Dqf1f65gNBhjETQWyUx--AHPsPCwBU,1066
-gisserver/parsers/gml/geometries.py,sha256=cgV3WogA7LyC_H_NF7dGoGLvLdQRACG6AlThRkX_jhU,3171
-gisserver/queries/__init__.py,sha256=zBLHOWKcU7PvBj6NHfGqcdUKCFJdL_np3_Mdn3bx-nE,893
-gisserver/queries/adhoc.py,sha256=hhLh3xB0UU--2tZwRgOWzonrjHM8OxCF2YYbl7NsxhE,7087
-gisserver/queries/base.py,sha256=w0hXefxX516oN3qdPYvM7huTewqrwxJmAseHHJ_BOgk,5891
-gisserver/queries/stored.py,sha256=RasXxlHlMCFtpO3EjIeMH6XPaDNvWbqJP23itR_byuU,7060
-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=KKrI0YYQqZWtTOyOkm-ZHuNyfwipdx0i0N8p7fggPU8,8675
-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.4.1.dist-info/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-django_gisserver-1.4.1.dist-info/METADATA,sha256=SpfcYIXvQiqTubhTKOAlarsHoGcMj9XeZQQRx1CJrW0,5874
-django_gisserver-1.4.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-django_gisserver-1.4.1.dist-info/top_level.txt,sha256=8zFCEMmkpixE4TPiOAlxSq3PD2EXvAeFKwG4yZoIIOQ,10
-django_gisserver-1.4.1.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 an 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 an "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()