c2cgeoportal-geoportal 2.6.0__py2.py3-none-any.whl → 2.7.1.156__py2.py3-none-any.whl

c2cgeoportal_geoportal/scripts/create_demo_theme.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -27,8 +25,6 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
-# pylint: disable=no-member
-
 
 import argparse
 import logging
@@ -40,7 +36,8 @@ from c2cgeoportal_geoportal.scripts import fill_arguments, get_appsettings, get_
 LOG = logging.getLogger(__name__)
 
 
-def main():
+def main() -> None:
+    """Create and populate the database tables."""
     parser = argparse.ArgumentParser(description="Create and populate the database tables.")
     fill_arguments(parser)
     options = parser.parse_args()

c2cgeoportal_geoportal/scripts/manage_users.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -27,32 +25,20 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
-# pylint: disable=no-member
-
 
 import argparse
 import sys
+from typing import cast
 
 import transaction
 
 from c2cgeoportal_geoportal.scripts import fill_arguments, get_appsettings, get_session
 
 
-def main():
-    """
-    Emergency user create and password reset script
-    example, reset toto password to foobar:
-    docker-compose exec geoportal manage-users --password=foobar toto
-    example, create user foo with password bar and role admin:
-    docker-compose exec geoportal manage-users --create --rolename=role_admin --password=bar foo
-
-    to get the options list, do:
-    docker-compose exec geoportal manage-users --help
-    """
+def get_argparser() -> argparse.ArgumentParser:
+    """Get the argument parser for this script."""
 
-    usage = """Usage: %prog [options] USERNAME
-
-Reset a user password.
+    usage = """Reset a user password.
 The username is used as password if the password is not provided with the corresponding option.
 User can be created if it does not exist yet."""
 
@@ -67,12 +53,27 @@ User can be created if it does not exist yet."""
     )
     parser.add_argument("--email", "-e", default=None, help="The user email")
     parser.add_argument("user", help="The user")
+    return parser
+
+
+def main() -> None:
+    """
+    Emergency user create and password reset script example.
+
+    Reset toto password to foobar: docker-compose
+    exec geoportal manage-users --password=foobar toto example, create user foo with password bar and role
+    admin: docker-compose exec geoportal manage-users --create --rolename=role_admin --password=bar foo.
+
+    to get the options list, do: docker-compose exec geoportal manage-users --help
+    """
+
+    parser = get_argparser()
     options = parser.parse_args()
     username = options.user
     settings = get_appsettings(options)
 
     with transaction.manager:
-        sess = get_session(settings, transaction.manager)
+        session = get_session(settings, transaction.manager)
 
         # Must be done only once we have loaded the project config
         from c2cgeoportal_commons.models.main import Role  # pylint: disable=import-outside-toplevel
@@ -81,13 +82,13 @@ User can be created if it does not exist yet."""
         print("\n")
 
         # Check that user exists
-        query = sess.query(User).filter_by(username=username)
+        query = session.query(User).filter_by(username=username)
 
         result = query.count()
         if result == 0:
             if not options.create:
                 # If doesn't exist and no -c option, throw error
-                print("User {} does not exist in database".format(username))
+                print(f"User {username} does not exist in database")
                 sys.exit(1)
             else:
                 if options.password is None:
@@ -96,46 +97,40 @@ User can be created if it does not exist yet."""
                     parser.error("The email is mandatory on user creation")
 
                 # Get roles
-                query_role = sess.query(Role).filter(Role.name == options.rolename)
+                query_role = session.query(Role).filter(Role.name == options.rolename)
 
                 if query_role.count() == 0:
                     # Role not found in db?
-                    print("Role matching {} does not exist in database".format(options.rolename))
+                    print(f"Role matching {options.rolename} does not exist in database")
                     sys.exit(1)
 
                 role = query_role.first()
 
                 user = User(
                     username=username,
-                    password=options.password,
-                    email=options.email,
+                    password=cast(str, options.password),
+                    email=cast(str, options.email),
                     settings_role=role,
                     roles=[role],
                 )
-                sess.add(user)
-
-                print(
-                    (
-                        "User {} created with password {} and role {}".format(
-                            username, options.password, options.rolename
-                        )
-                    )
-                )
+                session.add(user)
+
+                print(f"User {username} created with password {options.password} and role {options.rolename}")
 
         else:
             # If user exists (assuming username are unique)
             user = query.first()
 
             if options.password is not None:
-                print("Password set to: {}".format(options.password))
-                user.password = "{}".format(options.password)
+                print(f"Password set to: {options.password}")
+                user.password = f"{options.password}"
 
             if options.email is not None:
                 user.email = options.email
 
-            sess.add(user)
+            session.add(user)
 
-            print("Password reset for user {}".format(username))
+            print(f"Password reset for user {username}")
 
 
 if __name__ == "__main__":

c2cgeoportal_geoportal/scripts/pcreate.py

@@ -0,0 +1,312 @@
+# Copyright (c) 2021-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import json
+import os
+import re
+import subprocess
+import sys
+from argparse import ArgumentParser
+from typing import Any, Dict, List, Optional, Type, Union, cast
+
+import pkg_resources
+import requests
+import yaml
+from cookiecutter.log import configure_logger
+from cookiecutter.main import cookiecutter
+
+_bad_chars_re = re.compile("[^a-zA-Z0-9_]")
+SCAFFOLDS_DIR = pkg_resources.resource_filename("c2cgeoportal_geoportal", "scaffolds")
+
+
+def get_argparser() -> ArgumentParser:
+    """Get the argument parser for this script."""
+
+    parser = ArgumentParser(
+        prog=sys.argv[0],
+        add_help=True,
+        description="Wrapper around cookiecutter that create appropriated context.",
+    )
+    parser.add_argument(
+        "-s",
+        "--scaffold",
+        dest="scaffold_names",
+        action="append",
+        help=("Add a scaffold to the create process " "(multiple -s args accepted)"),
+    )
+    parser.add_argument(
+        "-l",
+        "--list",
+        dest="list",
+        action="store_true",
+        help="List all available scaffold names",
+    )
+    parser.add_argument(
+        "--package-name",
+        dest="package_name",
+        action="store",
+        help="Package name to use. The name provided is "
+        "assumed to be a valid Python package name, and "
+        "will not be validated. By default the package "
+        "name is derived from the value of "
+        "output_directory.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        dest="overwrite",
+        action="store_true",
+        help="Always overwrite",
+    )
+    parser.add_argument(
+        "output_directory",
+        nargs="?",
+        default=None,
+        help="The directory where the project will be " "created.",
+    )
+    return parser
+
+
+def main() -> int:
+    """Entry point to run PCreateCommand."""
+    command = PCreateCommand(sys.argv)
+    try:
+        return command.run()
+    except KeyboardInterrupt:  # pragma: no cover
+        return 1
+
+
+class PCreateCommand:
+    """
+    Wrapper around cookiecutter with appropriated context creator for our scaffolds.
+
+    This is a port of Pyramid 1 PCreateCommand using cookiecutter as a backend.
+    """
+
+    def __init__(self, argv: List[str], quiet: bool = False) -> None:
+        self.quiet = quiet
+        self.parser = get_argparser()
+        self.args = self.parser.parse_args(argv[1:])
+        self.scaffolds = self.all_scaffolds()
+
+    def run(self) -> int:
+        if self.args.list:
+            return self.show_scaffolds()
+        if not self.args.scaffold_names and not self.args.output_directory:
+            if not self.quiet:  # pragma: no cover
+                self.parser.print_help()
+                self.out("")
+                self.show_scaffolds()
+            return 2
+
+        return self.render_scaffolds()
+
+    @property
+    def output_path(self) -> str:
+        return cast(str, os.path.abspath(os.path.normpath(self.args.output_directory)))
+
+    def render_scaffolds(self) -> int:
+        verbose = True
+        debug_file = None
+        configure_logger(stream_level="DEBUG" if verbose else "INFO", debug_file=debug_file)
+
+        context = self.get_context()
+
+        for scaffold_name in self.args.scaffold_names:
+            # Needed to be backward compatible for the `test-upgrade init` command
+            if scaffold_name.startswith("c2cgeoportal_"):
+                scaffold_name = scaffold_name[len("c2cgeoportal_") :]
+            self.out(f"Rendering scaffold: {scaffold_name}")
+            cookiecutter(
+                template=os.path.join(SCAFFOLDS_DIR, scaffold_name),
+                extra_context=context,
+                no_input=True,
+                overwrite_if_exists=self.args.overwrite,
+                output_dir=os.path.dirname(self.output_path),
+            )
+        return 0
+
+    def show_scaffolds(self) -> int:
+        scaffolds = sorted(self.scaffolds)
+        if scaffolds:
+            self.out("Available scaffolds:")
+            for scaffold in scaffolds:
+                self.out(f"  {scaffold}")
+        else:
+            self.out("No scaffolds available")
+        return 0
+
+    @staticmethod
+    def all_scaffolds() -> List[str]:
+        return os.listdir(SCAFFOLDS_DIR)
+
+    def out(self, msg: str) -> None:
+        if not self.quiet:
+            print(msg)
+
+    def get_context(self) -> Dict[str, Union[str, int]]:
+        output_dir = self.output_path
+        project_name = os.path.basename(output_dir)
+        if self.args.package_name is None:
+            pkg_name = _bad_chars_re.sub("", project_name.lower().replace("-", "_"))
+        else:
+            pkg_name = self.args.package_name
+
+        context: Dict[str, Union[str, int]] = {
+            "project": project_name,
+            "package": pkg_name,
+            "authtkt_secret": gen_authtkt_secret(),
+        }
+        context.update(self.read_project_file())
+        if os.environ.get("CI") == "true":
+            context["authtkt_secret"] = (  # nosec
+                "io7heoDui8xaikie1rushaeGeiph8Bequei6ohchaequob6viejei0xooWeuvohf"
+            )
+
+        self.get_var(context, "srid", "Spatial Reference System Identifier (e.g. 2056): ", int)
+        srid = cast(int, context["srid"])
+        extent = self.epsg2bbox(srid)
+        self.get_var(
+            context,
+            "extent",
+            (
+                f"Extent (minx miny maxx maxy): in EPSG: {srid} projection, default is "
+                f"[{extent[0]} {extent[1]} {extent[2]} {extent[3]}]: "
+                if extent
+                else f"Extent (minx miny maxx maxy): in EPSG: {srid} projection: "
+            ),
+        )
+        match = re.match(
+            r"([\d.]+)[,; ] *([\d.]+)[,; ] *([\d.]+)[,; ] *([\d.]+)",
+            cast(str, context["extent"]),
+        )
+        if match is not None:
+            extent = [match.group(n + 1) for n in range(4)]
+        assert extent is not None
+        context["extent"] = ",".join(extent)
+        context["extent_mapserver"] = " ".join(extent)
+
+        if context["package"] == "site":
+            raise ValueError(
+                "Sorry, you may not name your package 'site'. "
+                "The package name 'site' has a special meaning in "
+                "Python.  Please name it anything except 'site'."
+            )
+
+        package_logger = context["package"]
+        if package_logger == "root":
+            # Rename the app logger in the rare case a project
+            # is named "root"
+            package_logger = "app"
+        context["package_logger"] = package_logger
+        context["geomapfish_version"] = os.environ["VERSION"]
+        # Used in the Docker files to shoos the version of the build image
+        context["geomapfish_version_tag"] = "GEOMAPFISH_VERSION"
+        context["geomapfish_version_tag_env"] = "${GEOMAPFISH_VERSION}"
+        geomapfish_major_version_tag = (
+            "GEOMAPFISH_VERSION"
+            if context.get("unsafe_long_version", False)
+            else "GEOMAPFISH_MAIN_MINOR_VERSION"
+        )
+        # Used in the Docker files to shoos the version of the run image
+        context["geomapfish_major_version_tag"] = geomapfish_major_version_tag
+        context["geomapfish_major_version_tag_env"] = "${" + geomapfish_major_version_tag + "}"
+        context["geomapfish_main_version"] = os.environ["MAJOR_VERSION"]
+        context["geomapfish_main_version_dash"] = os.environ["MAJOR_VERSION"].replace(".", "-")
+        context["geomapfish_main_minor_version"] = os.environ["MAJOR_MINOR_VERSION"]
+
+        return context
+
+    def read_project_file(self) -> Dict[str, Union[str, int]]:
+        project_file = os.path.join(self.output_path, "project.yaml")
+        if os.path.exists(project_file):
+            with open(project_file, encoding="utf8") as f:
+                project = yaml.safe_load(f)
+                return cast(Dict[str, Union[str, int]], project.get("template_vars", {}))
+        else:
+            return {}
+
+    @staticmethod
+    def get_var(
+        context: Dict[str, Any],
+        name: str,
+        prompt: str,
+        type_: Optional[Type[Any]] = None,
+    ) -> None:
+        if name.upper() in os.environ and os.environ[name.upper()] != "":
+            value = os.environ.get(name.upper())
+        else:
+            value = context.get(name)
+
+        if value is None:
+            value = input(prompt).strip()
+
+        if type_ is not None and not isinstance(value, type_):
+            try:
+                value = type_(value)
+            except ValueError:
+                print(f"The attribute {name}={value} is not a {type_}")
+                sys.exit(1)
+
+        context[name] = value
+
+    @staticmethod
+    def epsg2bbox(srid: int) -> Optional[List[str]]:
+        try:
+            r = requests.get(f"https://epsg.io/?format=json&q={srid}")
+            bbox = r.json()["results"][0]["bbox"]
+            r = requests.get(
+                "https://epsg.io/trans?s_srs=4326&t_srs={srid}&data={bbox[1]},{bbox[0]}".format(
+                    srid=srid, bbox=bbox
+                )
+            )
+            r1 = r.json()[0]
+            r = requests.get(
+                "https://epsg.io/trans?s_srs=4326&t_srs={srid}&data={bbox[3]},{bbox[2]}".format(
+                    srid=srid, bbox=bbox
+                )
+            )
+            r2 = r.json()[0]
+            return [r1["x"], r2["y"], r2["x"], r1["y"]]
+        except requests.RequestException:
+            print("Failed to establish a connection to epsg.io.")
+        except json.JSONDecodeError:
+            print("epsg.io doesn't return a correct json.")
+        except IndexError:
+            print("Unable to get the bbox")
+        except Exception as exception:
+            print(f"unexpected error: {str(exception)}")
+        return None
+
+
+def gen_authtkt_secret() -> str:
+    """Generate a random authtkt secret."""
+    return subprocess.run(["pwgen", "64"], stdout=subprocess.PIPE, check=True).stdout.decode().strip()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main() or 0)

c2cgeoportal_geoportal/scripts/theme2fts.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2014-2020, Camptocamp SA
+# Copyright (c) 2014-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -31,19 +29,25 @@
 import gettext
 import os
 import sys
-from argparse import ArgumentParser
-from typing import Any, Dict, List, Set
+from argparse import ArgumentParser, Namespace
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set
 
+import pyramid.config
 import transaction
 from sqlalchemy import func
+from sqlalchemy.orm.session import Session
 
-from c2cgeoportal_geoportal.lib.bashcolor import RED, colorize
+from c2cgeoportal_geoportal.lib.bashcolor import Color, colorize
 from c2cgeoportal_geoportal.lib.fulltextsearch import Normalize
 from c2cgeoportal_geoportal.lib.i18n import LOCALE_PATH
 from c2cgeoportal_geoportal.scripts import fill_arguments, get_appsettings, get_session
 
+if TYPE_CHECKING:
+    import c2cgeoportal_commons.models.main
+
 
-def main():
+def get_argparser() -> ArgumentParser:
+    """Get the argument parser for this script."""
     parser = ArgumentParser(
         prog=sys.argv[0],
         add_help=True,
@@ -53,7 +57,7 @@ def main():
     parser.add_argument(
         "--locale-folder",
         default=LOCALE_PATH,
-        help="The folder where the locale files are stored (default to {})".format(LOCALE_PATH),
+        help=f"The folder where the locale files are stored (default is {LOCALE_PATH})",
     )
     parser.add_argument("--interfaces", action="append", help="the interfaces to export")
     parser.add_argument(
@@ -85,7 +89,13 @@ def main():
     )
     parser.add_argument("--package", help="the application package")
     fill_arguments(parser)
-    options = parser.parse_args()
+    return parser
+
+
+def main() -> None:
+    """Run the command."""
+
+    options = get_argparser().parse_args()
     settings = get_appsettings(options)
 
     with transaction.manager:
@@ -95,7 +105,13 @@ def main():
 
 
 class Import:
-    def __init__(self, session, settings, options):
+    """
+    To import all the themes, layer groups and layers names into the full-text search table.
+
+    Done by interface and by language.
+    """
+
+    def __init__(self, session: Session, settings: pyramid.config.Configurator, options: Namespace):
         self.options = options
         self.imported: Set[Any] = set()
         package = settings["package"]
@@ -106,9 +122,9 @@ class Import:
 
         fts_missing_langs = [lang for lang in self.languages if lang not in self.fts_languages]
         if fts_missing_langs:
-            msg = "Keys {} are missing in fulltextsearch languages configuration.".format(fts_missing_langs)
+            msg = f"Keys {fts_missing_langs} are missing in fulltextsearch languages configuration."
             if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE":
-                print(colorize(msg, RED))
+                print(colorize(msg, Color.RED))
                 self.languages = [lang for lang in self.languages if lang in self.fts_languages]
             else:
                 raise KeyError(KeyError(msg))
@@ -122,19 +138,19 @@ class Import:
         )
 
         self.session = session
-        self.session.execute(FullTextSearch.__table__.delete().where(FullTextSearch.from_theme))  # noqa
+        self.session.execute(FullTextSearch.__table__.delete().where(FullTextSearch.from_theme))
 
         self._: Dict[str, gettext.NullTranslations] = {}
         for lang in self.languages:
             try:
                 self._[lang] = gettext.translation(
-                    "{}_geoportal-client".format(package),
+                    f"{package}_geoportal-client",
                     options.locale_folder.format(package=package),
                     [lang],
                 )
             except OSError as e:
                 self._[lang] = gettext.NullTranslations()
-                print("Warning: {} (language: {})".format(e, lang))
+                print(f"Warning: {e} (language: {lang})")
 
         query = self.session.query(Interface)
         if options.interfaces is not None:
@@ -156,7 +172,13 @@ class Import:
             for theme in self.session.query(Theme).all():
                 self._add_theme(theme, role)
 
-    def _add_fts(self, item, interface, action, role):
+    def _add_fts(
+        self,
+        item: "c2cgeoportal_commons.models.main.TreeItem",
+        interface: "c2cgeoportal_commons.models.main.Interface",
+        action: str,
+        role: Optional["c2cgeoportal_commons.models.main.Role"],
+    ) -> None:
         from c2cgeoportal_commons.models.main import FullTextSearch  # pylint: disable=import-outside-toplevel
 
         key = (
@@ -177,14 +199,18 @@ class Import:
                     self.fts_languages[lang],
                     " ".join(
                         [self.fts_normalizer(self._[lang].gettext(item.name))]
-                        + [v.strip() for m in item.get_metadatas("searchAlias") for v in m.value.split(",")]
+                        + [v.strip() for m in item.get_metadata("searchAlias") for v in m.value.split(",")]
                     ),
                 )
                 fts.actions = [{"action": action, "data": item.name}]
                 fts.from_theme = True
                 self.session.add(fts)
 
-    def _add_theme(self, theme, role=None):
+    def _add_theme(
+        self,
+        theme: "c2cgeoportal_commons.models.main.Theme",
+        role: Optional["c2cgeoportal_commons.models.main.Role"] = None,
+    ) -> None:
         fill = False
         for interface in self.interfaces:
             if interface in theme.interfaces:
@@ -198,13 +224,29 @@ class Import:
                     if role is None or theme.id not in self.public_theme[interface.id]:
                         self._add_fts(theme, interface, "add_theme", role)
 
-    def _add_block(self, group, interface, role):
+    def _add_block(
+        self,
+        group: "c2cgeoportal_commons.models.main.LayerGroup",
+        interface: "c2cgeoportal_commons.models.main.Interface",
+        role: Optional["c2cgeoportal_commons.models.main.Role"],
+    ) -> bool:
         return self._add_group(group, interface, self.options.blocks, role)
 
-    def _add_folder(self, group, interface, role):
+    def _add_folder(
+        self,
+        group: "c2cgeoportal_commons.models.main.LayerGroup",
+        interface: "c2cgeoportal_commons.models.main.Interface",
+        role: Optional["c2cgeoportal_commons.models.main.Role"],
+    ) -> bool:
         return self._add_group(group, interface, self.options.folders, role)
 
-    def _add_group(self, group, interface, export, role):
+    def _add_group(
+        self,
+        group: "c2cgeoportal_commons.models.main.LayerGroup",
+        interface: "c2cgeoportal_commons.models.main.Interface",
+        export: bool,
+        role: Optional["c2cgeoportal_commons.models.main.Role"],
+    ) -> bool:
         from c2cgeoportal_commons.models.main import LayerGroup  # pylint: disable=import-outside-toplevel
 
         fill = False
@@ -224,13 +266,20 @@ class Import:
         return fill
 
     @staticmethod
-    def _layer_visible(layer, role):
+    def _layer_visible(
+        layer: "c2cgeoportal_commons.models.main.Layer", role: "c2cgeoportal_commons.models.main.Role"
+    ) -> bool:
         for restrictionarea in layer.restrictionareas:
             if role in restrictionarea.roles:
                 return True
         return False
 
-    def _add_layer(self, layer, interface, role):
+    def _add_layer(
+        self,
+        layer: "c2cgeoportal_commons.models.main.Layer",
+        interface: "c2cgeoportal_commons.models.main.Interface",
+        role: Optional["c2cgeoportal_commons.models.main.Role"],
+    ) -> bool:
         if role is None:
             fill = layer.public and interface in layer.interfaces
         else: