c2cgeoportal-geoportal 2.5.0.100__py2.py3-none-any.whl → 2.7.1.83__py2.py3-none-any.whl

c2cgeoportal_geoportal/views/layers.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2012-2020, Camptocamp SA
+# Copyright (c) 2012-2022, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -27,15 +25,19 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
-from datetime import datetime
+import json
 import logging
 import os
-from typing import Dict, List, Union
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Set, Tuple, TypedDict, cast
 
+import geojson.geometry
+import pyramid.request
+import pyramid.response
+import sqlalchemy.ext.declarative
 from geoalchemy2 import Geometry
 from geoalchemy2 import func as ga_func
 from geoalchemy2.shape import from_shape, to_shape
-import geojson
 from geojson.feature import Feature, FeatureCollection
 from papyrus.protocol import Protocol, create_filter
 from papyrus.xsd import XSDGenerator
@@ -50,7 +52,7 @@ from pyramid.view import view_config
 from shapely.geometry import asShape
 from shapely.geos import TopologicalError
 from shapely.ops import cascaded_union
-from sqlalchemy import Enum, Numeric, String, Text, Unicode, UnicodeText, distinct, exc, func
+from sqlalchemy import Enum, Numeric, String, Text, Unicode, UnicodeText, exc, func
 from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
 from sqlalchemy.orm.properties import ColumnProperty
 from sqlalchemy.orm.util import class_mapper
@@ -58,48 +60,51 @@ from sqlalchemy.sql import and_, or_
 
 from c2cgeoportal_commons import models
 from c2cgeoportal_geoportal.lib import get_roles_id
-from c2cgeoportal_geoportal.lib.caching import (
-    NO_CACHE,
-    PRIVATE_CACHE,
-    PUBLIC_CACHE,
-    get_region,
-    set_common_headers,
-)
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 from c2cgeoportal_geoportal.lib.dbreflection import _AssociationProxy, get_class, get_table
 
+if TYPE_CHECKING:
+    from c2cgeoportal_commons.models import main  # pylint: disable=ungrouped-imports.useless-suppression
 LOG = logging.getLogger(__name__)
 CACHE_REGION = get_region("std")
 
 
 class Layers:
-    def __init__(self, request):
+    """
+    All the layers view (editing).
+
+    Mapfish protocol implementation
+    """
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
         self.settings = request.registry.settings.get("layers", {})
         self.layers_enum_config = self.settings.get("enum")
 
     @staticmethod
-    def _get_geom_col_info(layer):
-        """ Return information about the layer's geometry column, namely
-        a ``(name, srid)`` tuple, where ``name`` is the name of the
-        geometry column, and ``srid`` its srid.
+    def _get_geom_col_info(layer: "main.Layer") -> Tuple[str, int]:
+        """
+        Return information about the layer's geometry column.
+
+        Namely a ``(name, srid)`` tuple, where ``name`` is the name of the geometry column,
+        and ``srid`` its srid.
 
-        This function assumes that the names of geometry attributes
-        in the mapped class are the same as those of geometry columns.
+        This function assumes that the names of geometry attributes in the mapped class are the same as those
+        of geometry columns.
         """
         mapped_class = get_layer_class(layer)
         for p in class_mapper(mapped_class).iterate_properties:
             if not isinstance(p, ColumnProperty):
-                continue  # pragma: no cover
+                continue
             col = p.columns[0]
             if isinstance(col.type, Geometry):
                 return col.name, col.type.srid
-        raise HTTPInternalServerError(
-            'Failed getting geometry column info for table "{0!s}".'.format(layer.geo_table)
-        )  # pragma: no cover
+        raise HTTPInternalServerError(f'Failed getting geometry column info for table "{layer.geo_table!s}".')
 
     @staticmethod
-    def _get_layer(layer_id):
-        """ Return a ``Layer`` object for ``layer_id``. """
+    def _get_layer(layer_id: int) -> "main.Layer":
+        """Return a ``Layer`` object for ``layer_id``."""
         from c2cgeoportal_commons.models.main import Layer  # pylint: disable=import-outside-toplevel
 
         layer_id = int(layer_id)
@@ -108,16 +113,19 @@ class Layers:
             query = query.filter(Layer.id == layer_id)
             layer, geo_table = query.one()
         except NoResultFound:
-            raise HTTPNotFound("Layer {0:d} not found".format(layer_id))
-        except MultipleResultsFound:  # pragma: no cover
-            raise HTTPInternalServerError("Too many layers found with id {0:d}".format(layer_id))
-        if not geo_table:  # pragma: no cover
-            raise HTTPNotFound("Layer {0:d} has no geo table".format(layer_id))
-        return layer
-
-    def _get_layers_for_request(self):
-        """ A generator function that yields ``Layer`` objects based
-        on the layer ids found in the ``layer_id`` matchdict. """
+            raise HTTPNotFound(f"Layer {layer_id:d} not found") from None
+        except MultipleResultsFound:
+            raise HTTPInternalServerError(f"Too many layers found with id {layer_id:d}") from None
+        if not geo_table:
+            raise HTTPNotFound(f"Layer {layer_id:d} has no geo table")
+        return cast("main.Layer", layer)
+
+    def _get_layers_for_request(self) -> Generator["main.Layer", None, None]:
+        """
+        Get a generator function that yields ``Layer`` objects.
+
+        Based on the layer ids found in the ``layer_id`` matchdict.
+        """
         try:
             layer_ids = (
                 int(layer_id) for layer_id in self.request.matchdict["layer_id"].split(",") if layer_id
@@ -125,29 +133,27 @@ class Layers:
             for layer_id in layer_ids:
                 yield self._get_layer(layer_id)
         except ValueError:
-            raise HTTPBadRequest(
-                "A Layer id in '{0!s}' is not an integer".format(self.request.matchdict["layer_id"])
-            )  # pragma: no cover
+            raise HTTPBadRequest(  # pylint: disable=raise-missing-from
+                f"A Layer id in '{self.request.matchdict['layer_id']}' is not an integer"
+            )
 
-    def _get_layer_for_request(self):
-        """ Return a ``Layer`` object for the first layer id found
-        in the ``layer_id`` matchdict. """
+    def _get_layer_for_request(self) -> "main.Layer":
+        """Return a ``Layer`` object for the first layer id found in the ``layer_id`` matchdict."""
         return next(self._get_layers_for_request())
 
-    def _get_protocol_for_layer(self, layer, **kwargs):
-        """ Returns a papyrus ``Protocol`` for the ``Layer`` object. """
+    def _get_protocol_for_layer(self, layer: "main.Layer", **kwargs: Any) -> Protocol:
+        """Return a papyrus ``Protocol`` for the ``Layer`` object."""
         cls = get_layer_class(layer)
         geom_attr = self._get_geom_col_info(layer)[0]
         return Protocol(models.DBSession, cls, geom_attr, **kwargs)
 
-    def _get_protocol_for_request(self, **kwargs):
-        """ Returns a papyrus ``Protocol`` for the first layer
-        id found in the ``layer_id`` matchdict. """
+    def _get_protocol_for_request(self, **kwargs: Any) -> Protocol:
+        """Return a papyrus ``Protocol`` for the first layer id found in the ``layer_id`` matchdict."""
         layer = self._get_layer_for_request()
         return self._get_protocol_for_layer(layer, **kwargs)
 
-    def _proto_read(self, layer):
-        """ Read features for the layer based on the self.request. """
+    def _proto_read(self, layer: "main.Layer") -> FeatureCollection:
+        """Read features for the layer based on the self.request."""
         from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
             Layer,
             RestrictionArea,
@@ -174,7 +180,7 @@ class Layers:
                 return proto.read(self.request)
             use_srid = srid
             collect_ra.append(to_shape(ra))
-        if not collect_ra:  # pragma: no cover
+        if not collect_ra:
             raise HTTPForbidden()
 
         filter1_ = create_filter(self.request, cls, geom_attr)
@@ -182,11 +188,14 @@ class Layers:
         filter2_ = ga_func.ST_Contains(from_shape(ra, use_srid), getattr(cls, geom_attr))
         filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
 
-        return proto.read(self.request, filter=filter_)
+        feature = proto.read(self.request, filter=filter_)
+        if isinstance(feature, HTTPException):
+            raise feature  # pylint: disable=raising-non-exception
+        return feature
 
-    @view_config(route_name="layers_read_many", renderer="geojson")
-    def read_many(self):
-        set_common_headers(self.request, "layers", NO_CACHE)
+    @view_config(route_name="layers_read_many", renderer="geojson")  # type: ignore
+    def read_many(self) -> FeatureCollection:
+        set_common_headers(self.request, "layers", Cache.PRIVATE_NO)
 
         features = []
         for layer in self._get_layers_for_request():
@@ -196,15 +205,15 @@ class Layers:
 
         return FeatureCollection(features)
 
-    @view_config(route_name="layers_read_one", renderer="geojson")
-    def read_one(self):
+    @view_config(route_name="layers_read_one", renderer="geojson")  # type: ignore
+    def read_one(self) -> Feature:
         from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
             Layer,
             RestrictionArea,
             Role,
         )
 
-        set_common_headers(self.request, "layers", NO_CACHE)
+        set_common_headers(self.request, "layers", Cache.PRIVATE_NO)
 
         layer = self._get_layer_for_request()
         protocol = self._get_protocol_for_layer(layer)
@@ -217,7 +226,7 @@ class Layers:
         if self.request.user is None:
             raise HTTPForbidden()
         geom = feature.geometry
-        if not geom or isinstance(geom, geojson.geometry.Default):  # pragma: no cover
+        if not geom or isinstance(geom, geojson.geometry.Default):
             return feature
         shape = asShape(geom)
         srid = self._get_geom_col_info(layer)[1]
@@ -235,22 +244,25 @@ class Layers:
 
         return feature
 
-    @view_config(route_name="layers_count", renderer="string")
-    def count(self):
-        set_common_headers(self.request, "layers", NO_CACHE)
+    @view_config(route_name="layers_count", renderer="string")  # type: ignore
+    def count(self) -> int:
+        set_common_headers(self.request, "layers", Cache.PRIVATE_NO)
 
         protocol = self._get_protocol_for_request()
-        return protocol.count(self.request)
+        count = protocol.count(self.request)
+        if isinstance(count, HTTPException):
+            raise count
+        return cast(int, count)
 
-    @view_config(route_name="layers_create", renderer="geojson")
-    def create(self):
+    @view_config(route_name="layers_create", renderer="geojson")  # type: ignore
+    def create(self) -> Optional[FeatureCollection]:
         from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
             Layer,
             RestrictionArea,
             Role,
         )
 
-        set_common_headers(self.request, "layers", NO_CACHE)
+        set_common_headers(self.request, "layers", Cache.PRIVATE_NO)
 
         if self.request.user is None:
             raise HTTPForbidden()
@@ -259,7 +271,7 @@ class Layers:
 
         layer = self._get_layer_for_request()
 
-        def check_geometry(_, feature, obj):
+        def check_geometry(_: Any, feature: Feature, obj: Any) -> None:
             del obj  # unused
             geom = feature.geometry
             if geom and not isinstance(geom, geojson.geometry.Default):
@@ -278,7 +290,7 @@ class Layers:
                 if allowed.scalar() == 0:
                     raise HTTPForbidden()
 
-                # check if geometry is valid
+                # Check if geometry is valid
                 if self._get_validation_setting(layer):
                     self._validate_geometry(spatial_elt)
 
@@ -299,15 +311,15 @@ class Layers:
             self.request.response.status_int = 400
             return {"error_type": "integrity_error", "message": str(e.orig.diag.message_primary)}
 
-    @view_config(route_name="layers_update", renderer="geojson")
-    def update(self):
+    @view_config(route_name="layers_update", renderer="geojson")  # type: ignore
+    def update(self) -> Feature:
         from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
             Layer,
             RestrictionArea,
             Role,
         )
 
-        set_common_headers(self.request, "layers", NO_CACHE)
+        set_common_headers(self.request, "layers", Cache.PRIVATE_NO)
 
         if self.request.user is None:
             raise HTTPForbidden()
@@ -317,7 +329,7 @@ class Layers:
         feature_id = self.request.matchdict.get("feature_id")
         layer = self._get_layer_for_request()
 
-        def check_geometry(_, feature, obj):
+        def check_geometry(_: Any, feature: Feature, obj: Any) -> None:
             # we need both the "original" and "new" geometry to be
             # within the restriction area
             geom_attr, srid = self._get_geom_col_info(layer)
@@ -342,15 +354,17 @@ class Layers:
             if allowed.scalar() == 0:
                 raise HTTPForbidden()
 
-            # check is geometry is valid
+            # Check is geometry is valid
             if self._get_validation_setting(layer):
                 self._validate_geometry(spatial_elt)
 
         protocol = self._get_protocol_for_layer(layer, before_update=check_geometry)
         try:
             feature = protocol.update(self.request, feature_id)
+            if isinstance(feature, HTTPException):
+                raise feature
             self._log_last_update(layer, feature)
-            return feature
+            return cast(Feature, feature)
         except TopologicalError as e:
             self.request.response.status_int = 400
             return {"error_type": "validation_error", "message": str(e)}
@@ -360,17 +374,17 @@ class Layers:
             return {"error_type": "integrity_error", "message": str(e.orig.diag.message_primary)}
 
     @staticmethod
-    def _validate_geometry(geom):
+    def _validate_geometry(geom: Geometry) -> None:
         if geom is not None:
-            simple = models.DBSession.query(func.ST_IsSimple(geom)).scalar()
+            simple = models.DBSession.query(func.ST_IsSimple(func.ST_GeomFromEWKB(geom))).scalar()
             if not simple:
                 raise TopologicalError("Not simple")
-            valid = models.DBSession.query(func.ST_IsValid(geom)).scalar()
+            valid = models.DBSession.query(func.ST_IsValid(func.ST_GeomFromEWKB(geom))).scalar()
             if not valid:
-                reason = models.DBSession.query(func.ST_IsValidReason(geom)).scalar()
+                reason = models.DBSession.query(func.ST_IsValidReason(func.ST_GeomFromEWKB(geom))).scalar()
                 raise TopologicalError(reason)
 
-    def _log_last_update(self, layer, feature):
+    def _log_last_update(self, layer: "main.Layer", feature: Feature) -> None:
         last_update_date = self.get_metadata(layer, "lastUpdateDateColumn")
         if last_update_date is not None:
             setattr(feature, last_update_date, datetime.now())
@@ -380,22 +394,22 @@ class Layers:
             setattr(feature, last_update_user, self.request.user.id)
 
     @staticmethod
-    def get_metadata(layer, key, default=None):
-        metadatas = layer.get_metadatas(key)
-        if len(metadatas) == 1:
-            metadata = metadatas[0]
-            return metadata.value
+    def get_metadata(layer: "main.Layer", key: str, default: Optional[str] = None) -> Optional[str]:
+        metadata = layer.get_metadata(key)
+        if len(metadata) == 1:
+            metadata = metadata[0]
+            return cast(str, metadata.value)
         return default
 
-    def _get_validation_setting(self, layer):
+    def _get_validation_setting(self, layer: "main.Layer") -> bool:
         # The validation UIMetadata is stored as a string, not a boolean
         should_validate = self.get_metadata(layer, "geometryValidation", None)
         if should_validate:
             return should_validate.lower() != "false"
-        return self.settings.get("geometry_validation", False)
+        return cast(bool, self.settings.get("geometry_validation", False))
 
-    @view_config(route_name="layers_delete")
-    def delete(self):
+    @view_config(route_name="layers_delete")  # type: ignore
+    def delete(self) -> pyramid.response.Response:
         from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
             Layer,
             RestrictionArea,
@@ -408,7 +422,7 @@ class Layers:
         feature_id = self.request.matchdict.get("feature_id")
         layer = self._get_layer_for_request()
 
-        def security_cb(_, obj):
+        def security_cb(_: Any, obj: Any) -> None:
             geom_attr = getattr(obj, self._get_geom_col_info(layer)[0])
             allowed = models.DBSession.query(func.count(RestrictionArea.id))
             allowed = allowed.join(RestrictionArea.roles)
@@ -424,12 +438,14 @@ class Layers:
 
         protocol = self._get_protocol_for_layer(layer, before_delete=security_cb)
         response = protocol.delete(self.request, feature_id)
-        set_common_headers(self.request, "layers", NO_CACHE, response=response)
+        if isinstance(response, HTTPException):
+            raise response  # pylint: disable=raising-non-exception
+        set_common_headers(self.request, "layers", Cache.PRIVATE_NO, response=response)
         return response
 
-    @view_config(route_name="layers_metadata", renderer="xsd")
-    def metadata(self):
-        set_common_headers(self.request, "layers", PRIVATE_CACHE)
+    @view_config(route_name="layers_metadata", renderer="xsd")  # type: ignore
+    def metadata(self) -> pyramid.response.Response:
+        set_common_headers(self.request, "layers", Cache.PRIVATE)
 
         layer = self._get_layer_for_request()
         if not layer.public and self.request.user is None:
@@ -437,38 +453,40 @@ class Layers:
 
         return get_layer_class(layer, with_last_update_columns=True)
 
-    @view_config(route_name="layers_enumerate_attribute_values", renderer="json")
-    def enumerate_attribute_values(self):
-        set_common_headers(self.request, "layers", PUBLIC_CACHE)
+    @view_config(route_name="layers_enumerate_attribute_values", renderer="json")  # type: ignore
+    def enumerate_attribute_values(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "layers", Cache.PUBLIC)
 
-        if self.layers_enum_config is None:  # pragma: no cover
+        if self.layers_enum_config is None:
             raise HTTPInternalServerError("Missing configuration")
         layername = self.request.matchdict["layer_name"]
         fieldname = self.request.matchdict["field_name"]
         # TODO check if layer is public or not
 
-        return self._enumerate_attribute_values(layername, fieldname)
+        return cast(Dict[str, Any], self._enumerate_attribute_values(layername, fieldname))
 
-    @CACHE_REGION.cache_on_arguments()
-    def _enumerate_attribute_values(self, layername, fieldname):
-        if layername not in self.layers_enum_config:  # pragma: no cover
-            raise HTTPBadRequest("Unknown layer: {0!s}".format(layername))
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def _enumerate_attribute_values(self, layername: str, fieldname: str) -> Dict[str, Any]:
+        if layername not in self.layers_enum_config:
+            raise HTTPBadRequest(f"Unknown layer: {layername!s}")
 
         layerinfos = self.layers_enum_config[layername]
-        if fieldname not in layerinfos["attributes"]:  # pragma: no cover
-            raise HTTPBadRequest("Unknown attribute: {0!s}".format(fieldname))
+        if fieldname not in layerinfos["attributes"]:
+            raise HTTPBadRequest(f"Unknown attribute: {fieldname!s}")
         dbsession_name = layerinfos.get("dbsession", "dbsession")
         dbsession = models.DBSessions.get(dbsession_name)
-        if dbsession is None:  # pragma: no cover
+        if dbsession is None:
             raise HTTPInternalServerError(
-                "No dbsession found for layer '{0!s}' ({1!s})".format(layername, dbsession_name)
+                f"No dbsession found for layer '{layername!s}' ({dbsession_name!s})"
             )
-        values = self.query_enumerate_attribute_values(dbsession, layerinfos, fieldname)
+        values = sorted(self.query_enumerate_attribute_values(dbsession, layerinfos, fieldname))
         enum = {"items": [{"value": value[0]} for value in values]}
         return enum
 
     @staticmethod
-    def query_enumerate_attribute_values(dbsession, layerinfos, fieldname):
+    def query_enumerate_attribute_values(
+        dbsession: sqlalchemy.orm.Session, layerinfos: Dict[str, Any], fieldname: str
+    ) -> Set[Tuple[str, ...]]:
         attrinfos = layerinfos["attributes"][fieldname]
         table = attrinfos["table"]
         layertable = get_table(table, session=dbsession)
@@ -479,18 +497,23 @@ class Layers:
         if "separator" in attrinfos:
             separator = attrinfos["separator"]
             attribute = func.unnest(func.string_to_array(func.string_agg(attribute, separator), separator))
-        return dbsession.query(distinct(attribute)).order_by(attribute).all()
+        return set(cast(List[Tuple[str, ...]], dbsession.query(attribute).order_by(attribute).all()))
 
 
-def get_layer_class(layer, with_last_update_columns=False):
+def get_layer_class(
+    layer: "main.Layer", with_last_update_columns: bool = False
+) -> sqlalchemy.ext.declarative.ConcreteBase:
     """
-    Get the SQLAlchemy class to edit a GeoMapFish layer
+    Get the SQLAlchemy class to edit a GeoMapFish layer.
 
-    :param layer:
-    :param with_last_update_columns: False to just have a class to access to the table and be able to
+    Arguments:
+
+        layer: The GeoMapFish layer
+        with_last_update_columns: False to just have a class to access to the table and be able to
            modify the last_update_columns, True to have a correct class to build the UI
            (without the hidden column).
-    :return: SQLAlchemy class
+
+    Returns: SQLAlchemy class
     """
     # Exclude the columns used to record the last features update
     exclude = [] if layer.exclude_properties is None else layer.exclude_properties.split(",")
@@ -501,13 +524,13 @@ def get_layer_class(layer, with_last_update_columns=False):
         last_update_user = Layers.get_metadata(layer, "lastUpdateUserColumn")
         if last_update_user is not None:
             exclude.append(last_update_user)
-    else:
-        exclude = []
 
     m = Layers.get_metadata(layer, "editingAttributesOrder")
     attributes_order = m.split(",") if m else None
     m = Layers.get_metadata(layer, "readonlyAttributes")
     readonly_attributes = m.split(",") if m else None
+    m = Layers.get_metadata(layer, "editingEnumerations")
+    enumerations_config = json.loads(m) if m else None
 
     primary_key = Layers.get_metadata(layer, "geotablePrimaryKey")
     cls = get_class(
@@ -515,11 +538,13 @@ def get_layer_class(layer, with_last_update_columns=False):
         exclude_properties=exclude,
         primary_key=primary_key,
         attributes_order=attributes_order,
+        enumerations_config=enumerations_config,
         readonly_attributes=readonly_attributes,
     )
 
     mapper = class_mapper(cls)
     column_properties = [p.key for p in mapper.iterate_properties if isinstance(p, ColumnProperty)]
+
     for attribute_name in attributes_order or []:
         if attribute_name not in column_properties:
             table = mapper.mapped_table
@@ -538,21 +563,36 @@ def get_layer_class(layer, with_last_update_columns=False):
     return cls
 
 
-def get_layer_metadatas(layer):
+class ColumnProperties(TypedDict, total=False):
+    """Collected metadata information related to an editing attribute."""
+
+    name: str
+    type: str
+    nillable: bool
+    srid: int
+    enumeration: List[str]
+    restriction: str
+    maxLength: int  # noqa
+    fractionDigits: int  # noqa
+    totalDigits: int  # noqa
+
+
+def get_layer_metadata(layer: "main.Layer") -> List[ColumnProperties]:
+    """Get the metadata related to a layer."""
     cls = get_layer_class(layer, with_last_update_columns=True)
-    edit_columns = []
+    edit_columns: List[ColumnProperties] = []
 
     for column_property in class_mapper(cls).iterate_properties:
         if isinstance(column_property, ColumnProperty):
 
             if len(column_property.columns) != 1:
-                raise NotImplementedError  # pragma: no cover
+                raise NotImplementedError
 
             column = column_property.columns[0]
 
             # Exclude columns that are primary keys
             if not column.primary_key:
-                properties = _convert_column_type(column.type)
+                properties: ColumnProperties = _convert_column_type(column.type)
                 properties["name"] = column.key
 
                 if column.nullable:
@@ -581,7 +621,7 @@ def get_layer_metadatas(layer):
     return edit_columns
 
 
-def _convert_column_type(column_type):
+def _convert_column_type(column_type: object) -> ColumnProperties:
     # SIMPLE_XSD_TYPES
     for cls, xsd_type in XSDGenerator.SIMPLE_XSD_TYPES.items():
         if isinstance(column_type, cls):
@@ -598,14 +638,13 @@ def _convert_column_type(column_type):
             return {"type": xsd_type, "srid": int(column_type.srid)}
 
         raise NotImplementedError(
-            "The geometry type '{}' is not supported, supported types: {}".format(
-                geometry_type, ",".join(XSDGenerator.SIMPLE_GEOMETRY_XSD_TYPES)
-            )
-        )  # pragma: no cover
+            f"The geometry type '{geometry_type}' is not supported, supported types: "
+            f"{','.join(XSDGenerator.SIMPLE_GEOMETRY_XSD_TYPES)}"
+        )
 
     # Enumeration type
     if isinstance(column_type, Enum):
-        restriction: Dict[str, Union[str, List[str]]] = {}
+        restriction: ColumnProperties = {}
         restriction["restriction"] = "enumeration"
         restriction["type"] = "xsd:string"
         restriction["enumeration"] = column_type.enums
@@ -619,17 +658,17 @@ def _convert_column_type(column_type):
 
     # Numeric Type
     if isinstance(column_type, Numeric):
-        xsd_type = {"type": "xsd:decimal"}
+        xsd_type2: ColumnProperties = {"type": "xsd:decimal"}
         if column_type.scale is None and column_type.precision is None:
-            return xsd_type
+            return xsd_type2
 
         if column_type.scale is not None:
-            xsd_type["fractionDigits"] = int(column_type.scale)
+            xsd_type2["fractionDigits"] = int(column_type.scale)
         if column_type.precision is not None:
-            xsd_type["totalDigits"] = int(column_type.precision)
-        return xsd_type
+            xsd_type2["totalDigits"] = int(column_type.precision)
+        return xsd_type2
 
     raise NotImplementedError(
-        "The type '{}' is not supported, supported types: "
-        "Geometry, Enum, String, Text, Unicode, UnicodeText, Numeric".format(type(column_type).__name__)
-    )  # pragma: no cover
+        f"The type '{type(column_type).__name__}' is not supported, supported types: "
+        "Geometry, Enum, String, Text, Unicode, UnicodeText, Numeric"
+    )