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

c2cgeoportal_geoportal/lib/wmstparsing.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2013-2020, Camptocamp SA
+# Copyright (c) 2013-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -29,12 +27,15 @@
 
 
 import datetime
-from typing import Optional, cast
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
 import isodate
 
+TimeExtent = Union["TimeExtentValue", "TimeExtentInterval"]
+
 
-def min_none(a, b):
+def min_none(a: Optional[datetime.datetime], b: Optional[datetime.datetime]) -> Optional[datetime.datetime]:
+    """Return the min value, support non in input."""
     if a is None:
         return b
     if b is None:
@@ -42,7 +43,8 @@ def min_none(a, b):
     return min(a, b)
 
 
-def max_none(a, b):
+def max_none(a: Optional[datetime.datetime], b: Optional[datetime.datetime]) -> Optional[datetime.datetime]:
+    """Return the max value, support non in input."""
     if a is None:
         return b
     if b is None:
@@ -52,21 +54,22 @@ def max_none(a, b):
 
 class TimeInformation:
     """
+    Collect the WMS time information.
+
     Arguments:
 
-    * ``extent`` A time extent instance (``TimeExtentValue`` or
-                 ``TimeExtentInterval``)
-    * ``mode`` The layer mode ("single", "range" or "disabled")
-    * ``widget`` The layer mode ("slider" (default) or "datepicker")
+        extent: A time extent instance (``TimeExtentValue`` or ``TimeExtentInterval``)
+        mode: The layer mode ("single", "range" or "disabled")
+        widget: The layer mode ("slider" (default) or "datepicker")
     """
 
-    def __init__(self):
-        self.extent: Optional[TimeExtentValue] = None
-        self.mode = None
-        self.widget = None
-        self.layer = None
+    def __init__(self) -> None:
+        self.extent: Optional[TimeExtent] = None
+        self.mode: Optional[str] = None
+        self.widget: Optional[str] = None
+        self.layer: Optional[Dict[str, Any]] = None
 
-    def merge(self, layer, extent, mode, widget):
+    def merge(self, layer: Dict[str, Any], extent: TimeExtent, mode: str, widget: str) -> None:
         layer_apply = self.layer == layer or (not self.has_time() and extent is not None)
 
         self.merge_extent(extent)
@@ -80,35 +83,37 @@ class TimeInformation:
             del self.layer["time"]
             self.layer = None
 
-    def merge_extent(self, extent):
+    def merge_extent(self, extent: TimeExtent) -> None:
         if self.extent is not None:
             self.extent.merge(extent)
         else:
             self.extent = extent
 
-    def merge_mode(self, mode):
+    def merge_mode(self, mode: str) -> None:
         if mode != "disabled":
             if self.mode is not None:
                 if self.mode != mode:
-                    raise ValueError("Could not mix time mode '{0!s}' and '{1!s}'".format(mode, self.mode))
+                    raise ValueError(f"Could not mix time mode '{mode!s}' and '{self.mode!s}'")
             else:
                 self.mode = mode
 
-    def merge_widget(self, widget):
+    def merge_widget(self, widget: Optional[str]) -> None:
         widget = "slider" if not widget else widget
+        assert widget is not None
 
         if self.widget is not None:
             if self.widget != widget:
-                raise ValueError("Could not mix time widget '{0!s}' and '{1!s}'".format(widget, self.widget))
+                raise ValueError(f"Could not mix time widget '{widget!s}' and '{self.widget!s}'")
         else:
             self.widget = widget
 
-    def has_time(self):
+    def has_time(self) -> bool:
         return self.extent is not None
 
-    def to_dict(self):
+    def to_dict(self) -> Optional[Dict[str, Any]]:
         if self.has_time():
-            time = cast(TimeExtentValue, self.extent).to_dict()
+            assert self.extent is not None
+            time = self.extent.to_dict()
             time["mode"] = self.mode
             time["widget"] = self.widget
             return time
@@ -116,34 +121,38 @@ class TimeInformation:
 
 
 class TimeExtentValue:
-    """
-    Represents time as a list of values.
-    """
-
-    def __init__(self, values, resolution, min_def_value, max_def_value):
+    """Represents time as a list of values."""
+
+    def __init__(
+        self,
+        values: Set[datetime.datetime],
+        resolution: str,
+        min_def_value: Optional[datetime.datetime],
+        max_def_value: Optional[datetime.datetime],
+    ):
         """
+        Initialise.
+
         Arguments:
 
-        * ``values`` A set() of datetime
-        * ``resolution`` The resolution from the mapfile time definition
-        * ``min_def_value`` the minimum default value as a datetime
-        * ``max_def_value`` the maximum default value as a datetime
+            values: A set() of datetime
+            resolution: The resolution from the mapfile time definition
+            min_def_value: the minimum default value as a datetime
+            max_def_value: the maximum default value as a datetime
         """
         self.values = values
         self.resolution = resolution
         self.min_def_value = min_def_value
         self.max_def_value = max_def_value
 
-    def merge(self, extent):
+    def merge(self, extent: TimeExtent) -> None:
         if not isinstance(extent, TimeExtentValue):
-            raise ValueError(
-                "Could not mix time defined as a list of " "values with other type of definition"
-            )
+            raise ValueError("Could not mix time defined as a list of values with other type of definition")
         self.values.update(extent.values)
         self.min_def_value = min_none(self.min_def_value, extent.min_def_value)
         self.max_def_value = max_none(self.max_def_value, extent.max_def_value)
 
-    def to_dict(self):
+    def to_dict(self) -> Dict[str, Any]:
         values = sorted(self.values)
         min_def_value = _format_date(self.min_def_value) if self.min_def_value else None
         max_def_value = _format_date(self.max_def_value) if self.max_def_value else None
@@ -159,20 +168,28 @@ class TimeExtentValue:
 
 
 class TimeExtentInterval:
-    """
-    Represents time with the help of a start, an end and an interval.
-    """
-
-    def __init__(self, start, end, interval, resolution, min_def_value, max_def_value):
+    """Represents time with the help of a start, an end and an interval."""
+
+    def __init__(
+        self,
+        start: datetime.datetime,
+        end: datetime.datetime,
+        interval: Tuple[int, int, int, int],
+        resolution: str,
+        min_def_value: Optional[datetime.datetime],
+        max_def_value: Optional[datetime.datetime],
+    ):
         """
+        Initialize.
+
         Arguments:
 
-        * ``start`` The start value as a datetime
-        * ``end`` The end value as a datetime
-        * ``interval`` The interval as a tuple (years, months, days, seconds)
-        * ``resolution`` The resolution from the mapfile time definition
-        * ``min_def_value`` the minimum default value as a datetime
-        * ``max_def_value`` the maximum default value as a datetime
+            start: The start value as a datetime
+            end: The end value as a datetime
+            interval: The interval as a tuple (years, months, days, seconds)
+            resolution: The resolution from the mapfile time definition
+            min_def_value: the minimum default value as a datetime
+            max_def_value: the maximum default value as a datetime
         """
         self.start = start
         self.end = end
@@ -181,31 +198,37 @@ class TimeExtentInterval:
         self.min_def_value = min_def_value
         self.max_def_value = max_def_value
 
-    def merge(self, extent):
+    def merge(self, extent: TimeExtent) -> None:
         if not isinstance(extent, TimeExtentInterval):
-            raise ValueError(
-                "Could not merge time defined as with an " " interval with other type of definition"
-            )
+            raise ValueError("Could not merge time defined as with an interval with other type of definition")
         if self.interval != extent.interval:
-            raise ValueError("Could not merge times defined with a " "different interval")
-        self.start = min_none(self.start, extent.start)
-        self.end = max_none(self.end, extent.end)
+            raise ValueError("Could not merge times defined with a different interval")
+        start = min_none(self.start, extent.start)
+        assert start is not None
+        self.start = start
+        end = max_none(self.end, extent.end)
+        assert end is not None
+        self.end = end
         self.min_def_value = (
             self.min_def_value
             if extent.min_def_value is None
-            else extent.min_def_value
-            if self.min_def_value is None
-            else min_none(self.min_def_value, extent.min_def_value)
+            else (
+                extent.min_def_value
+                if self.min_def_value is None
+                else min_none(self.min_def_value, extent.min_def_value)
+            )
         )
         self.max_def_value = (
             self.max_def_value
             if extent.max_def_value is None
-            else extent.max_def_value
-            if self.max_def_value is None
-            else max_none(self.max_def_value, extent.max_def_value)
+            else (
+                extent.max_def_value
+                if self.max_def_value is None
+                else max_none(self.max_def_value, extent.max_def_value)
+            )
         )
 
-    def to_dict(self):
+    def to_dict(self) -> Dict[str, Any]:
         min_def_value = _format_date(self.min_def_value) if self.min_def_value is not None else None
         max_def_value = _format_date(self.max_def_value) if self.max_def_value is not None else None
 
@@ -219,10 +242,9 @@ class TimeExtentInterval:
         }
 
 
-def parse_extent(extent, default_values):
+def parse_extent(extent: List[str], default_values: str) -> TimeExtent:
     """
-    Parse a time extend from OWSLib to a `̀ TimeExtentValue`` or a
-    ``TimeExtentInterval``
+    Parse a time extend from OWSLib to a `̀ TimeExtentValue`` or a ``TimeExtentInterval``.
 
     Two formats are supported:
     * ['start/end/interval']
@@ -236,7 +258,7 @@ def parse_extent(extent, default_values):
         if extent[0].count("/") > 0:
             # case "start/end/interval"
             if len(extent) > 1 or extent[0].count("/") != 2:
-                raise ValueError("Unsupported time definition '{0!s}'".format(extent))
+                raise ValueError(f"Unsupported time definition '{extent!s}'")
             s, e, i = extent[0].split("/")
             start = _parse_date(s)
             end = _parse_date(e)
@@ -246,20 +268,19 @@ def parse_extent(extent, default_values):
         # case "value1, value2, ..., valueN"
         dates = [_parse_date(d) for d in extent]
         resolution = dates[0][0]
-        values = set(d[1] for d in dates)
+        values = {d[1] for d in dates}
 
         return TimeExtentValue(values, resolution, min_def_value, max_def_value)
-    raise ValueError("Invalid time extent format '{}'".format(extent))
+    raise ValueError(f"Invalid time extent format '{extent}'")
 
 
-def _parse_default_values(default_values):
+def _parse_default_values(default_values: str) -> Tuple[datetime.datetime, Optional[datetime.datetime]]:
     """
-    Parse the 'default' value from OWSLib's defaulttimeposition
-    and return a maximum of two dates. default value must be a
-    slash separated String.
-    return None on the seconde value if it does not exist.
+    Parse the 'default' value from OWSLib's defaulttimeposition and return a maximum of two dates.
+
+    default value must be a slash separated String. return None on the seconde value if it does not exist.
     """
-    if default_values is None:  # pragma: no cover
+    if default_values is None:
         return None, None
 
     def_value = default_values.split("/")
@@ -273,14 +294,16 @@ def _parse_default_values(default_values):
     return min_def_value, max_def_value
 
 
-def _parse_date(date):
+def _parse_date(date: str) -> Tuple[str, datetime.datetime]:
     """
-    Parses a string into a tuple containing:
+    Parse a date string.
+
+    Return a tuple containing:
 
     * the resolution: "year", "month", "day" or "second"
     * the date as a datetime
 
-    The returned datetime always has a timezone (default to UTC)
+    The returned datetime always has a timezone (default is UTC)
     """
     resolutions = {"year": "%Y", "month": "%Y-%m", "day": "%Y-%m-%d"}
 
@@ -288,7 +311,7 @@ def _parse_date(date):
         try:
             dt = datetime.datetime.strptime(date, pattern)
             return resolution, dt.replace(tzinfo=isodate.UTC)
-        except Exception:
+        except Exception:  # nosec
             pass
 
     try:
@@ -296,33 +319,35 @@ def _parse_date(date):
         if dt.tzinfo is None:
             dt = dt.replace(tzinfo=isodate.UTC)
         return "second", dt
-    except Exception:
-        raise ValueError("Invalid date format '{0!s}'".format(date))
+    except Exception as e:
+        raise ValueError(f"Invalid date format '{date}'") from e
 
 
-def _format_date(date):
-    assert isinstance(date, datetime.datetime)
+def _format_date(date: datetime.datetime) -> str:
     str_ = isodate.datetime_isoformat(date)
+    assert isinstance(str_, str)
     if date.tzinfo is None:
         str_ += "Z"
     return str_
 
 
-def _parse_duration(duration):
+def _parse_duration(duration: str) -> Tuple[int, int, int, int]:
     """
-    Parses an ISO 8601 duration (i.e. "P2DT5S") and returns a tuple containing:
+    Parse an ISO 8601 duration (i.e. "P2DT5S").
+
+    Return a tuple containing:
 
     * years
     * months
     * days
     * seconds
     """
-    duration = isodate.parse_duration(duration)
+    parsed_duration = isodate.parse_duration(duration)
 
     # casting years and months to int as isodate might return a float
     return (
-        int(duration.years) if hasattr(duration, "years") else 0,
-        int(duration.months) if hasattr(duration, "months") else 0,
-        duration.days,
-        duration.seconds,
+        int(parsed_duration.years) if hasattr(parsed_duration, "years") else 0,
+        int(parsed_duration.months) if hasattr(parsed_duration, "months") else 0,
+        parsed_duration.days,
+        parsed_duration.seconds,
     )

c2cgeoportal_geoportal/lib/xsd.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2019, Camptocamp SA
+# Copyright (c) 2018-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -29,19 +27,26 @@
 
 
 from io import BytesIO
+from typing import Any, Callable, Dict, Optional, Type, Union, cast
 
+import sqlalchemy.sql.schema
 from papyrus.xsd import XSDGenerator as PapyrusXSDGenerator
 from papyrus.xsd import tag
+from sqlalchemy.ext.declarative import DeclarativeMeta
 from sqlalchemy.orm.properties import ColumnProperty
 from sqlalchemy.orm.util import class_mapper
 
 
-class XSDGenerator(PapyrusXSDGenerator):
-    def add_class_properties_xsd(self, tb, cls):
-        """ Add the XSD for the class properties to the ``TreeBuilder``. And
-        call the user ``sequence_callback``. """
-        mapper = class_mapper(cls)
+class XSDGenerator(PapyrusXSDGenerator):  # type: ignore
+    """Extends the PapyrusXSDGenerator."""
+
+    def add_class_properties_xsd(self, tb: str, cls: DeclarativeMeta) -> None:
+        """
+        Add the XSD for the class properties to the ``TreeBuilder``.
 
+        And call the user ``sequence_callback``.
+        """
+        mapper = class_mapper(cls)
         properties = []
         if cls.__attributes_order__:
             for attribute_name in cls.__attributes_order__:
@@ -63,7 +68,7 @@ class XSDGenerator(PapyrusXSDGenerator):
         if self.sequence_callback:
             self.sequence_callback(tb, cls)
 
-    def add_column_property_xsd(self, tb, column_property):
+    def add_column_property_xsd(self, tb: str, column_property: ColumnProperty) -> None:
         column = column_property.columns[0]
         if column.foreign_keys:
             self.add_association_proxy_xsd(tb, column_property)
@@ -71,7 +76,7 @@ class XSDGenerator(PapyrusXSDGenerator):
 
         super().add_column_property_xsd(tb, column_property)
 
-    def add_association_proxy_xsd(self, tb, column_property):
+    def add_association_proxy_xsd(self, tb: str, column_property: ColumnProperty) -> None:
         from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
 
         column = column_property.columns[0]
@@ -82,6 +87,8 @@ class XSDGenerator(PapyrusXSDGenerator):
         relationship_property = class_mapper(cls).get_property(association_proxy.target)
         target_cls = relationship_property.argument
         query = DBSession.query(getattr(target_cls, association_proxy.value_attr))
+        if association_proxy.order_by is not None:
+            query = query.order_by(getattr(target_cls, association_proxy.order_by))
         attrs = {}
         if association_proxy.nullable:
             attrs["minOccurs"] = "0"
@@ -95,8 +102,7 @@ class XSDGenerator(PapyrusXSDGenerator):
                             pass
             self.element_callback(tb4, column)
 
-    # pylint: disable=method-hidden
-    def element_callback(self, tb, column):
+    def element_callback(self, tb: str, column: sqlalchemy.sql.schema.Column) -> None:
         if column.info.get("readonly"):
             with tag(tb, "xsd:annotation"):
                 with tag(tb, "xsd:appinfo"):
@@ -105,12 +111,14 @@ class XSDGenerator(PapyrusXSDGenerator):
 
 
 class XSD:
+    """The XSD file generator on a pyramid view."""
+
     def __init__(
         self,
-        include_primary_keys=False,
-        include_foreign_keys=False,
-        sequence_callback=None,
-        element_callback=None,
+        include_primary_keys: bool = False,
+        include_foreign_keys: bool = False,
+        sequence_callback: Optional[str] = None,
+        element_callback: Optional[str] = None,
     ):
         self.generator = XSDGenerator(
             include_primary_keys=include_primary_keys,
@@ -119,14 +127,16 @@ class XSD:
             element_callback=element_callback,
         )
 
-    def __call__(self, table):
-        def _render(cls, system):
+    def __call__(
+        self, table: str
+    ) -> Callable[[Union[Type[str], Type[bytes]], Dict[str, Any]], Optional[bytes]]:
+        def _render(cls: Union[Type[str], Type[bytes]], system: Dict[str, Any]) -> Optional[bytes]:
             request = system.get("request")
             if request is not None:
                 response = request.response
                 response.content_type = "application/xml"
                 io = self.generator.get_class_xsd(BytesIO(), cls)
-                return io.getvalue()
+                return cast(bytes, io.getvalue())
             return None
 
         return _render

c2cgeoportal_geoportal/resources.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2019, Camptocamp SA
+# Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -27,18 +25,26 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
+from typing import List
+
+import pyramid.request
+
 
 class Root:
-    def __init__(self, request):
-        self.request = request  # pragma: no cover
+    """The pyramid root object."""
 
+    def __init__(self, request: pyramid.request.Request):
+        self.request = request
 
-def defaultgroupsfinder(username, request):
+
+def defaultgroupsfinder(username: str, request: pyramid.request.Request) -> List[str]:
     """
-    The c2cgeoportal default group finder. To be used as the callback of the ``AuthTktAuthenticationPolicy``
-    or any callback-based authentication policy.
+    Get the c2cgeoportal default group finder.
+
+    To be used as the callback of the ``AuthTktAuthenticationPolicy`` or any callback-based authentication
+    policy.
     """
     del username  # unused
     if not hasattr(request, "user") or request.user is None:
-        return []  # pragma: no cover
+        return []
     return [role.name for role in request.user.roles]

c2cgeoportal_geoportal/scaffolds/advance_create/ci/config.yaml

@@ -0,0 +1,26 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/camptocamp/c2cciutils/master/c2cciutils/schema.json
+
+checks:
+  black: False
+  isort: False
+  prettier: False
+  codespell: False
+  eof: False
+  required_workflows: False
+  dependabot_config: False
+  prospector_config: False
+  setup: False
+
+version:
+  branch_to_version_re:
+    - from: (prod-[0-9]+-[0-9]+)
+      to: \1
+    - from: (int-[0-9]+-[0-9]+)
+      to: \1
+
+publish:
+  pypi: false
+  docker:
+    images:
+      - name: camptocamp/{{cookiecutter.package}}-config
+      - name: camptocamp/{{cookiecutter.package}}-geoportal

c2cgeoportal_geoportal/scaffolds/advance_create/cookiecutter.json

@@ -0,0 +1,18 @@
+{
+  "project": "test_project",
+  "package": "test_project",
+  "srid": "2056",
+  "extent": "",
+  "extent_mapserver": "",
+  "authtkt_secret": "",
+  "unsafe_long_version": false,
+  "geomapfish_version": "",
+  "geomapfish_main_version": "",
+  "geomapfish_main_version_dash": "",
+  "geomapfish_main_minor_version": "",
+  "geomapfish_version_tag": "",
+  "geomapfish_version_tag_env": "",
+  "geomapfish_major_version_tag": "",
+  "geomapfish_major_version_tag_env": "",
+  "_copy_without_render": ["*.po", "*/contextualdata.html"]
+}

c2cgeoportal_geoportal/scaffolds/advance_create/{{cookiecutter.project}}/geoportal/.dockerignore

@@ -0,0 +1,6 @@
+Dockerfile
+vars*.yaml
+CONST_vars.yaml
+CONST_config-schema.yaml
+{{cookiecutter.package}}_geoportal/locale
+{{cookiecutter.package}}_geoportal/static

c2cgeoportal_geoportal/scaffolds/advance_create/{{cookiecutter.project}}/geoportal/.eslintrc.yaml

@@ -0,0 +1,19 @@
+extends:
+  - eslint:recommended
+
+globals:
+  '{{cookiecutter.package}}': false
+
+env:
+  es6: true
+  node: true
+  browser: true
+  jquery: true
+
+parserOptions:
+  sourceType: module
+  ecmaVersion: 2020
+
+rules:
+  no-console: 0
+  no-unused-vars: 0

c2cgeoportal_geoportal/scaffolds/{create/+dot+prospector.yaml → advance_create/{{cookiecutter.project}}/geoportal/.prospector.yaml}

@@ -1,7 +1,6 @@
----
-strictness: veryhigh
+max-line-length: 110
 
-pep8:
+pycodestyle:
   options:
     max-line-length: 110
   disable:
@@ -14,9 +13,14 @@ pylint:
     - too-many-locals
     - too-many-statements
     - too-many-branches
+    - c-extension-no-member
+
+pyflakes:
+  disable:
+    - F401
 
 mccabe:
   run: false
 
-mypy:
+bandit:
   run: true