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

gisserver/db.py

@@ -2,14 +2,19 @@
 
 from __future__ import annotations
 
+import logging
 from functools import lru_cache, reduce
 
-from django.contrib.gis.db.models import functions
+from django.contrib.gis.db.models import Extent, PolygonField, functions
+from django.contrib.gis.db.models.fields import ExtentField
 from django.db import connection, connections, models
 
 from gisserver import conf
-from gisserver.geometries import CRS
-from gisserver.types import GmlElement
+from gisserver.crs import CRS, WGS84
+from gisserver.geometries import WGS84BoundingBox
+from gisserver.types import GeometryXsdElement
+
+logger = logging.getLogger(__name__)
 
 
 class AsEWKT(functions.GeoFunc):
@@ -26,6 +31,8 @@ class AsEWKT(functions.GeoFunc):
 
 
 class AsGML(functions.AsGML):
+    """An overwritten ST_AsGML() function to handle PostGIS extensions."""
+
     name = "AsGML"
 
     def __init__(
@@ -34,20 +41,55 @@ class AsGML(functions.AsGML):
         version=3,
         precision=conf.GISSERVER_DB_PRECISION,
         envelope=False,
+        is_latlon=False,
         **extra,
     ):
-        # Note that Django's AsGml, version=2, precision=8
-        # the options is postgres-only.
+        # Note that Django's AsGml the defaults are: version=2, precision=8
         super().__init__(expression, version, precision, **extra)
         self.envelope = envelope
+        self.is_latlon = is_latlon
 
     def as_postgresql(self, compiler, connection, **extra_context):
         # Fill options parameter (https://postgis.net/docs/ST_AsGML.html)
         options = 33 if self.envelope else 1  # 32 = bbox, 1 = long CRS urn
+        if self.is_latlon:
+            # PostGIS provides the data in longitude/latitude format (east/north to look like x/y).
+            # However, WFS 2.0 fixed their axis by following the authority. The ST_AsGML() doesn't
+            # detect this on their own. It needs to be told to flip the coordinates.
+            # Passing option 16 flips the coordinates unconditionally, like using ST_FlipCoordinates()
+            # but more efficiently done during rendering. That happens in:
+            # https://github.com/postgis/postgis/blob/81e2bc783b77cc740291445e992658e1db7179e0/liblwgeom/lwout_gml.c#L121
+            options |= 16
+
         template = f"%(function)s(%(expressions)s, {options})"
         return self.as_sql(compiler, connection, template=template, **extra_context)
 
 
+class ST_SetSRID(functions.Transform):
+    """PostGIS function to assign an SRID to geometry.
+    When this is applied to the result from an ``Extent`` aggegrate,
+    it will convert that ``BBOX(...)`` value into a ``POLYGON(...)``.
+    """
+
+    name = "SetSRID"
+    geom_param_pos = ()
+
+    @property
+    def geo_field(self):
+        return PolygonField(srid=self.source_expressions[1].value)
+
+
+class Box2D(functions.GeomOutputGeoFunc):
+    """PostGIS function (without ST_) that converts a ``POLYGON(...)`` back to a ``BOX(...)``."""
+
+    name = "Box2D"
+    function = "Box2D"  # no ST_ prefix.
+    output_field = ExtentField()
+
+    def convert_value(self, value, expression, connection):
+        return connection.ops.convert_extent(value)
+
+
 class ST_Union(functions.Union):
     name = "Union"
     arity = None
@@ -59,6 +101,31 @@ class ST_Union(functions.Union):
         return self.as_sql(compiler, connection, **extra_context)
 
 
+def get_wgs84_bounding_box(
+    queryset: models.QuerySet, geo_element: GeometryXsdElement
+) -> WGS84BoundingBox:
+    """Calculate the WGS84 bounding box for a feature.
+
+    Note that the ``<ows:WGS84BoundingBox>`` element
+    always uses longitude/latitude, and doesn't describe a CRS.
+    """
+    if connections[queryset.db].vendor == "postgresql":
+        # Allow a more efficient way to combine geometry first, transform once later
+        box = queryset.aggregate(
+            box=Box2D(
+                functions.Transform(
+                    ST_SetSRID(Extent(geo_element.orm_path), srid=geo_element.source_srid),
+                    srid=WGS84.srid,
+                )
+            )
+        )["box"]
+    else:
+        # Need to transform each element to srid 4326 before combining it in an extent.
+        box = queryset.aggregate(box=Extent(get_db_geometry_target(geo_element, WGS84)))["box"]
+
+    return WGS84BoundingBox(*box) if box else None
+
+
 def get_geometries_union(
     expressions: list[str | functions.GeoFunc], using="default"
 ) -> str | functions.Union:
@@ -78,63 +145,71 @@ def get_geometries_union(
         return reduce(functions.Union, expressions)
 
 
-def conditional_transform(
-    expression: str | functions.GeoFunc, expression_srid: int, output_srid: int
-) -> str | functions.Transform:
-    """Apply a CRS Transform to the queried field if that is needed."""
-    if expression_srid != output_srid:
-        expression = functions.Transform(expression, srid=output_srid)
-    return expression
-
-
-def build_db_annotations(
-    selects: dict[str, str | functions.Func],
-    name_template: str,
-    wrapper_func: type[functions.Func],
-) -> dict:
-    """Utility to build annotations for all geometry fields for an XSD type.
-    This is used by various DB-optimized rendering methods.
+def replace_queryset_geometries(
+    queryset: models.QuerySet,
+    geo_elements: list[GeometryXsdElement],
+    output_crs: CRS,
+    wrapper_func: type[functions.GeoFunc],
+    **wrapper_kwargs,
+) -> models.QuerySet:
+    """Replace the queryset geometry retrieval with a database-rendered version.
+
+    This uses absolute paths in the queryset, but can use relative paths for related querysets.
     """
-    return {
-        escape_xml_name(name, name_template): wrapper_func(target)
-        for name, target in selects.items()
-    }
+    defer_names = []
+    as_geo_map = {}
+    for geo_element in geo_elements:
+        if geo_element.source is not None:  # excludes GmlBoundedByElement
+            defer_names.append(geo_element.local_orm_path)
+            annotation_name = _as_annotation_name(geo_element.local_orm_path, wrapper_func)
+            as_geo_map[annotation_name] = wrapper_func(
+                get_db_geometry_target(geo_element, output_crs, use_relative_path=True),
+                **wrapper_kwargs,
+            )
+
+    if not defer_names:
+        return queryset
+
+    logger.debug(
+        "DB rendering: QuerySet for %s replacing %r with %r",
+        queryset.model._meta.label,
+        defer_names,
+        list(as_geo_map.keys()),
+    )
+    return queryset.defer(*defer_names).annotate(**as_geo_map)
 
 
-def get_db_annotation(instance: models.Model, name: str, name_template: str):
-    """Retrieve the value that an annotation has added to the model."""
-    # The "name" allows any XML-tag elements, escape the most obvious
-    escaped_name = escape_xml_name(name, name_template)
+def get_db_rendered_geometry(
+    instance: models.Model, geo_element: GeometryXsdElement, replacement: type[functions.GeoFunc]
+) -> str:
+    """Retrieve the database-rendered geometry.
+    This includes formatted EWKT or GML output, rendered by the database.
+    """
+    annotation_name = _as_annotation_name(geo_element.local_orm_path, replacement)
     try:
-        return getattr(instance, escaped_name)
+        return getattr(instance, annotation_name)
     except AttributeError as e:
+        prefix = _as_annotation_name("", replacement)
+        available = ", ".join(key for key in instance.__dict__ if key.startswith(prefix)) or "none"
         raise AttributeError(
-            f" DB annotation {instance._meta.model_name}.{escaped_name}"
-            f" not found (using {name_template})"
+            f" DB annotation {instance._meta.label}.{annotation_name} not found. Found {available}."
         ) from e
 
 
 @lru_cache
-def escape_xml_name(name: str, template="{name}") -> str:
+def _as_annotation_name(name: str, func: type[functions.GeoFunc]) -> str:
     """Escape an XML name to be used as annotation name."""
-    return template.format(name=name.replace(".", "_"))
+    return f"_{func.__name__}_{name.replace('.', '_')}"
 
 
-def get_db_geometry_selects(
-    gml_elements: list[GmlElement], output_crs: CRS
-) -> dict[str, str | functions.Transform]:
-    """Utility to generate select clauses for the geometry fields of a type.
-    Key is the xsd element name, value is the database select expression.
+def get_db_geometry_target(
+    geo_element: GeometryXsdElement, output_crs: CRS, use_relative_path: bool = False
+) -> str | functions.Transform:
+    """Translate a GML geometry field into the proper expression for retrieving it from the database.
+    The path will be wrapped into a CRS Transform function if needed.
     """
-    return {
-        gml_element.name: get_db_geometry_target(gml_element, output_crs)
-        for gml_element in gml_elements
-        if gml_element.source is not None
-    }
-
-
-def get_db_geometry_target(gml_element: GmlElement, output_crs: CRS) -> str | functions.Transform:
-    """Wrap the selection of a geometry field in a CRS Transform if needed."""
-    return conditional_transform(
-        gml_element.orm_path, gml_element.source.srid, output_srid=output_crs.srid
-    )
+    orm_path = geo_element.local_orm_path if use_relative_path else geo_element.orm_path
+    if geo_element.source_srid != output_crs.srid:
+        return functions.Transform(orm_path, srid=output_crs.srid)
+    else:
+        return orm_path

gisserver/exceptions.py

@@ -8,10 +8,126 @@ https://docs.opengeospatial.org/is/09-025r2/09-025r2.html#35
 https://docs.opengeospatial.org/is/09-025r2/09-025r2.html#411
 """
 
+from __future__ import annotations
+
+import logging
+import typing
+from contextlib import contextmanager
+
 from django.conf import settings
+from django.core.exceptions import FieldError, ValidationError
+from django.db import InternalError, ProgrammingError
 from django.http import HttpResponse
 from django.utils.html import format_html
 
+from gisserver import conf
+
+if typing.TYPE_CHECKING:
+    from gisserver.parsers import wfs20
+
+logger = logging.getLogger(__name__)
+
+
+@contextmanager
+def wrap_parser_errors(name: str, locator: str):
+    """Convert the value into a Python format.
+    This catches any typical exceptions and transforms them into an OWSException.
+    """
+    try:
+        yield
+    except ExternalParsingError as e:
+        raise OperationParsingFailed(
+            f"Unable to parse {name} argument: {e}", locator=locator
+        ) from None
+    except (TypeError, ValueError, NotImplementedError) as e:
+        # TypeError/ValueError are raised by most handlers for unexpected data
+        # The NotImplementedError can be raised by fes parsing.
+        raise InvalidParameterValue(f"Invalid {name} argument: {e}", locator=locator) from None
+
+
+@contextmanager
+def wrap_filter_errors(query: wfs20.QueryExpression):  # noqa:C901
+    """Perform a QuerySet/filter creation operation.
+    and trap many parser errors in the making of it."""
+    try:
+        yield
+    except ExternalParsingError as e:
+        # Bad input data
+        _log_filter_error(query, logging.ERROR, e)
+        raise OperationParsingFailed(str(e), locator=query.query_locator) from e
+    except ExternalValueError as e:
+        # Bad input data
+        _log_filter_error(query, logging.ERROR, e)
+        raise InvalidParameterValue(str(e), locator=query.query_locator) from e
+    except ValidationError as e:
+        # Bad input data
+        _log_filter_error(query, logging.ERROR, e)
+        raise OperationParsingFailed(
+            "\n".join(map(str, e.messages)),
+            locator=query.query_locator,
+        ) from e
+    except FieldError as e:
+        # e.g. doing a LIKE on a foreign key, or requesting an unknown field.
+        if not conf.GISSERVER_WRAP_FILTER_DB_ERRORS:
+            raise
+        _log_filter_error(query, logging.ERROR, e)
+        raise InvalidParameterValue(
+            "Internal error when processing filter",
+            locator=query.query_locator,
+        ) from e
+    except (InternalError, ProgrammingError) as e:
+        # e.g. comparing datetime against integer
+        if not conf.GISSERVER_WRAP_FILTER_DB_ERRORS:
+            raise
+        logger.exception("WFS request failed: %s\nQuery: %r", str(e), query)
+        msg = str(e)
+        locator = "srsName" if "Cannot find SRID" in msg else query.query_locator
+        raise InvalidParameterValue(f"Invalid request: {msg}", locator=locator) from e
+    except (TypeError, ValueError) as e:
+        # TypeError/ValueError could reference a datatype mismatch in an
+        # ORM query, but it could also be an internal bug. In most cases,
+        # this is already caught by XsdElement.validate_comparison().
+        raise
+        if _is_orm_error(e):
+            if query.query_locator == "STOREDQUERY_ID":
+                # This is a fallback, ideally the stored query performs its own validation.
+                raise InvalidParameterValue(
+                    f"Invalid stored query parameter: {e}", locator=query.query_locator
+                ) from e
+            else:
+                raise InvalidParameterValue(
+                    f"Invalid filter query: {e}", locator=query.query_locator
+                ) from e
+        raise
+
+
+def _is_orm_error(exception: Exception) -> bool:
+    """Tell whether an exception is caused by the ORM."""
+    traceback = exception.__traceback__
+    while traceback.tb_next is not None:
+        traceback = traceback.tb_next
+        if "/django/db/models/query" in traceback.tb_frame.f_code.co_filename:
+            return True
+    return False
+
+
+def _log_filter_error(query, level, exc):
+    """Report a filtering parsing error in the logging"""
+    filter = getattr(query, "filter", None)  # AdhocQuery only
+    fes_xml = filter.source if filter is not None else "(not provided)"
+    try:
+        sql = exc.__cause__.cursor.query.decode()
+    except AttributeError:
+        logger.log(level, "WFS query failed: %s\nFilter:\n%s", exc, fes_xml)
+    else:
+        logger.log(
+            level,
+            "WFS query failed: %s\nSQL Query: %s\n\nFilter:\n%s",
+            exc,
+            sql,
+            fes_xml,
+        )
+
 
 class ExternalValueError(ValueError):
     """Raise a ValueError for external input.
@@ -24,6 +140,14 @@ class ExternalParsingError(ValueError):
     """Raise a ValueError for a parsing problem."""
 
 
+class XmlElementNotSupported(ExternalParsingError):
+    """Raise a ValueError when an XML tag is not known by the parser at all."""
+
+
+class InvalidXmlElement(ExternalParsingError):
+    """Raise a ValueError when a particular XML tag wasn't expected."""
+
+
 class OWSException(Exception):
     """Base class for XML based exceptions in this module."""
 
@@ -38,7 +162,7 @@ class OWSException(Exception):
     def __init__(self, text=None, code=None, locator=None, status_code=None):
         text = text or self.text_template.format(code=self.code, locator=locator)
         if (code and len(text) < len(code)) or (locator and len(text) < len(locator)):
-            raise ValueError("text/locator arguments are switched")
+            raise ValueError(f"text/locator arguments are switched: {text!r}, locator={locator!r}")
 
         super().__init__(text)
         self.locator = locator
@@ -46,15 +170,19 @@ class OWSException(Exception):
         self.code = code or self.code or self.__class__.__name__
         self.status_code = status_code or self.status_code
 
-    def as_response(self):
+    def as_response(self) -> HttpResponse:
+        """Return the excetion as HTTP response."""
+        logger.debug("Returning HTTP %d for %s: %s", self.status_code, self.code, self.text)
+        xml_body = self.as_xml()
         return HttpResponse(
-            b'<?xml version="1.0" encoding="UTF-8"?>\n%b' % self.as_xml().encode("utf-8"),
+            b'<?xml version="1.0" encoding="UTF-8"?>\n%b' % xml_body.encode("utf-8"),
             content_type="text/xml; charset=utf-8",
             status=self.status_code,
             reason=self.reason,
         )
 
-    def as_xml(self):
+    def as_xml(self) -> str:
+        """Serialize the exception to an XML string."""
         return format_html(
             "<ows:ExceptionReport"
             ' xmlns:ows="http://www.opengis.net/ows/1.1"'

gisserver/extensions/__init__.py

@@ -0,0 +1,4 @@
+"""Package that allows third party code to extend the server.
+
+This allows registering extra stored procedures or filter functions.
+"""

gisserver/{parsers/fes20 → extensions}/functions.py

@@ -1,4 +1,15 @@
-"""Functions to be callable from fes."""
+"""Functions to be callable from query filters.
+
+By using the :attr:`function_registry`, custom stored functions can be registered in this server.
+These are called by the filter queries using the :class:`~gisserver.parsers.fes20.expressions.Function` element.
+Out of the box, various built-in functions are present.
+
+Built-in options are documented in :ref:`functions`.
+
+Most of the out-of-the box options are inspired
+by `GeoServer <https://docs.geoserver.org/latest/en/user/filter/function_reference.html>`_.
+Functions which already have a fes-syntax equivalent have been are omitted.
+"""
 
 from __future__ import annotations
 
@@ -6,15 +17,16 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Union
 
+import django
 from django.contrib.gis.db.models import functions as gis
 from django.db import models
 from django.db.models import functions
-from django.db.models.expressions import Combinable
+from django.db.models.expressions import Combinable, Value
 
 from gisserver.exceptions import InvalidParameterValue
 from gisserver.types import XsdTypes
 
-__all__ = ["function_registry"]
+__all__ = ["function_registry", "FesFunctionRegistry", "FesFunction"]
 
 FesArg = Union[Combinable, models.Q]
 FesFunctionBody = Union[models.Func, Callable[..., models.Func]]
@@ -22,8 +34,14 @@ FesFunctionBody = Union[models.Func, Callable[..., models.Func]]
 
 @dataclass(order=True)
 class FesFunction:
-    """Wrapper that defines a fes function, with type descriptions.
-    This is also used to provide metadata to the GetCapabilities call.
+    """A registered database function that can be used by ``<fes:Function name="...">``.
+
+    The :class:`~gisserver.parsers.fes20.expressions.Function` class will resolve
+    these registered functions by name, and call :meth:`build_query` to include them
+    in the database query. This will actually insert a Django ORM function in the query!
+
+    This wrapper class also provides the metadata and type descriptions of the function,
+    which is exposed in the ``GetCapabilities`` call.
     """
 
     #: Name of the function
@@ -50,7 +68,7 @@ class FesFunction:
 
 
 class FesFunctionRegistry:
-    """Registry of functions to be callable by <fes:Function>.
+    """Registry of functions to be callable by ``<fes:Function>``.
 
     The registered functions should be capable of running an SQL function.
     """
@@ -59,9 +77,11 @@ class FesFunctionRegistry:
         self.functions = {}
 
     def __bool__(self):
+        """Tell whether there are functions"""
         return bool(self.functions)
 
     def __iter__(self):
+        """Iterate over the functions"""
         return iter(sorted(self.functions.values()))  # for template rendering
 
     def register(
@@ -102,19 +122,15 @@ class FesFunctionRegistry:
             return self.functions[function_name]
         except KeyError:
             raise InvalidParameterValue(
-                "filter", f"Unsupported function: {function_name}"
+                f"Unsupported function: {function_name}", locator="filter"
             ) from None
 
 
+#: The function registry
 function_registry = FesFunctionRegistry()
 
 
 # Register a set of default SQL functions.
-# These are based on GeoServer:
-# https://docs.geoserver.org/latest/en/user/filter/function_reference.html
-# Not implemented:
-# - Aggregates (like Collection_*)
-# - Comparisons (which already has fes variants)
 
 # -- strings
 
@@ -125,6 +141,27 @@ function_registry.register(
     returns=XsdTypes.string,
 )
 
+function_registry.register(
+    "strIndexOf",
+    lambda string, substring: (functions.StrIndex(string, Value(substring)) - 1),
+    arguments={"string": XsdTypes.string, "substring": XsdTypes.string},
+    returns=XsdTypes.string,
+)
+
+function_registry.register(
+    "strSubstring",
+    lambda string, begin, end: functions.Substr(string, begin + 1, end - begin),
+    arguments={"string": XsdTypes.string, "begin": XsdTypes.integer, "end": XsdTypes.integer},
+    returns=XsdTypes.string,
+)
+
+function_registry.register(
+    "strSubstringStart",
+    lambda string, begin, end: functions.Substr(string, begin + 1),
+    arguments={"string": XsdTypes.string, "begin": XsdTypes.integer},
+    returns=XsdTypes.string,
+)
+
 function_registry.register(
     "strToLowerCase",
     functions.Lower,
@@ -306,25 +343,25 @@ function_registry.register(
 # -- geometric
 
 function_registry.register(
-    "Area",
+    "area",
     gis.Area,
-    arguments={"geometry": XsdTypes.gmlAbstractGeometryType},
+    arguments={"geom": XsdTypes.gmlAbstractGeometryType},
     returns=XsdTypes.double,
 )
 
 function_registry.register(
-    "Centroid",
+    "centroid",
     gis.Centroid,
-    arguments={"features": XsdTypes.gmlAbstractGeometryType},
+    arguments={"geom": XsdTypes.gmlAbstractGeometryType},
     returns=XsdTypes.string,
 )
 
 function_registry.register(
-    "Difference",
+    "difference",
     gis.Difference,
     arguments={
-        "geometry1": XsdTypes.gmlAbstractGeometryType,
-        "geometry2": XsdTypes.gmlAbstractGeometryType,
+        "a": XsdTypes.gmlAbstractGeometryType,
+        "b": XsdTypes.gmlAbstractGeometryType,
     },
     returns=XsdTypes.string,
 )
@@ -333,35 +370,98 @@ function_registry.register(
     "distance",
     gis.Distance,
     arguments={
-        "geometry1": XsdTypes.gmlAbstractGeometryType,
-        "geometry2": XsdTypes.gmlAbstractGeometryType,
+        "a": XsdTypes.gmlAbstractGeometryType,
+        "b": XsdTypes.gmlAbstractGeometryType,
     },
     returns=XsdTypes.double,
 )
 
 function_registry.register(
-    "Envelope",
+    "envelope",
     gis.Envelope,
+    arguments={"geom": XsdTypes.gmlAbstractGeometryType},
+    returns=XsdTypes.gmlAbstractGeometryType,  # returns point or polygon
+)
+
+function_registry.register(
+    "geomLength",
+    gis.Length,
     arguments={"geometry": XsdTypes.gmlAbstractGeometryType},
-    returns=XsdTypes.string,
+    returns=XsdTypes.float,
 )
 
 function_registry.register(
-    "Intersection",
+    "intersection",
     gis.Intersection,
     arguments={
-        "geometry1": XsdTypes.gmlAbstractGeometryType,
-        "geometry2": XsdTypes.gmlAbstractGeometryType,
+        "a": XsdTypes.gmlAbstractGeometryType,
+        "b": XsdTypes.gmlAbstractGeometryType,
     },
-    returns=XsdTypes.string,
+    returns=XsdTypes.gmlAbstractGeometryType,
 )
 
+if django.VERSION >= (4, 2):
+    function_registry.register(
+        "isEmpty",
+        gis.IsEmpty,
+        arguments={
+            "geom": XsdTypes.gmlAbstractGeometryType,
+        },
+        returns=XsdTypes.boolean,
+    )
+
 function_registry.register(
-    "Union",
+    "isValid",
+    gis.IsValid,
+    arguments={
+        "geom": XsdTypes.gmlAbstractGeometryType,
+    },
+    returns=XsdTypes.boolean,
+)
+
+function_registry.register(
+    "numGeometries",
+    gis.NumGeometries,
+    arguments={
+        "collection": XsdTypes.gmlAbstractGeometryType,
+    },
+    returns=XsdTypes.integer,
+)
+
+function_registry.register(
+    "numPoints",
+    gis.NumPoints,
+    arguments={
+        "collection": XsdTypes.gmlAbstractGeometryType,
+    },
+    returns=XsdTypes.integer,
+)
+
+function_registry.register(
+    "perimeter",
+    gis.Perimeter,
+    arguments={
+        "geom": XsdTypes.gmlAbstractGeometryType,
+    },
+    returns=XsdTypes.integer,
+)
+
+function_registry.register(
+    "symDifference",
+    gis.SymDifference,
+    arguments={
+        "a": XsdTypes.gmlAbstractGeometryType,
+        "b": XsdTypes.gmlAbstractGeometryType,
+    },
+    returns=XsdTypes.gmlAbstractGeometryType,
+)
+
+function_registry.register(
+    "union",
     gis.Union,
     arguments={
-        "geometry1": XsdTypes.gmlAbstractGeometryType,
-        "geometry2": XsdTypes.gmlAbstractGeometryType,
+        "a": XsdTypes.gmlAbstractGeometryType,
+        "b": XsdTypes.gmlAbstractGeometryType,
     },
-    returns=XsdTypes.string,
+    returns=XsdTypes.gmlAbstractGeometryType,
 )