Sphinx 7.1.2__py3-none-any.whl → 7.2.0__py3-none-any.whl

sphinx/transforms/post_transforms/images.py

@@ -4,19 +4,22 @@ from __future__ import annotations
 
 import os
 import re
+from hashlib import sha1
 from math import ceil
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from docutils import nodes
 
-from sphinx.application import Sphinx
 from sphinx.locale import __
 from sphinx.transforms import SphinxTransform
-from sphinx.util import logging, requests, sha1
+from sphinx.util import logging, requests
 from sphinx.util.http_date import epoch_to_rfc1123, rfc1123_to_epoch
 from sphinx.util.images import get_image_extension, guess_mimetype, parse_data_uri
 from sphinx.util.osutil import ensuredir
 
+if TYPE_CHECKING:
+    from sphinx.application import Sphinx
+
 logger = logging.getLogger(__name__)
 
 MAX_FILENAME_LEN = 32
@@ -57,13 +60,13 @@ class ImageDownloader(BaseImageConverter):
                 basename = basename.split('?')[0]
             if basename == '' or len(basename) > MAX_FILENAME_LEN:
                 filename, ext = os.path.splitext(node['uri'])
-                basename = sha1(filename.encode()).hexdigest() + ext
+                basename = sha1(filename.encode(), usedforsecurity=False).hexdigest() + ext
             basename = re.sub(CRITICAL_PATH_CHAR_RE, "_", basename)
 
             dirname = node['uri'].replace('://', '/').translate({ord("?"): "/",
                                                                  ord("&"): "/"})
             if len(dirname) > MAX_FILENAME_LEN:
-                dirname = sha1(dirname.encode()).hexdigest()
+                dirname = sha1(dirname.encode(), usedforsecurity=False).hexdigest()
             ensuredir(os.path.join(self.imagedir, dirname))
             path = os.path.join(self.imagedir, dirname, basename)
 
@@ -125,7 +128,7 @@ class DataURIExtractor(BaseImageConverter):
             return
 
         ensuredir(os.path.join(self.imagedir, 'embeded'))
-        digest = sha1(image.data).hexdigest()
+        digest = sha1(image.data, usedforsecurity=False).hexdigest()
         path = os.path.join(self.imagedir, 'embeded', digest + ext)
         self.app.env.original_image_uri[path] = node['uri']
 
@@ -217,11 +220,12 @@ class ImageConverter(BaseImageConverter):
                 if rule in self.conversion_rules:
                     return rule
 
-        raise ValueError('No conversion rule found')
+        msg = 'No conversion rule found'
+        raise ValueError(msg)
 
     def is_available(self) -> bool:
         """Return the image converter is available or not."""
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def guess_mimetypes(self, node: nodes.image) -> list[str]:
         if '?' in node['candidates']:
@@ -262,7 +266,7 @@ class ImageConverter(BaseImageConverter):
         *_from* is a path of the source image file, and *_to* is a path
         of the destination file.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 def setup(app: Sphinx) -> dict[str, Any]:

sphinx/util/__init__.py

@@ -6,7 +6,6 @@ import hashlib
 import os
 import posixpath
 import re
-import sys
 from importlib import import_module
 from os import path
 from typing import IO, Any
@@ -17,6 +16,7 @@ from sphinx.locale import __
 from sphinx.util import display as _display
 from sphinx.util import exceptions as _exceptions
 from sphinx.util import http_date as _http_date
+from sphinx.util import index_entries as _index_entries
 from sphinx.util import logging
 from sphinx.util import osutil as _osutil
 from sphinx.util.console import strip_colors  # NoQA: F401
@@ -51,8 +51,7 @@ url_re: re.Pattern[str] = re.compile(r'(?P<schema>.+)://.*')
 # High-level utility functions.
 
 def docname_join(basedocname: str, docname: str) -> str:
-    return posixpath.normpath(
-        posixpath.join('/' + basedocname, '..', docname))[1:]
+    return posixpath.normpath(posixpath.join('/' + basedocname, '..', docname))[1:]
 
 
 def get_filetype(source_suffix: dict[str, str], filename: str) -> str:
@@ -105,26 +104,20 @@ class FilenameUniqDict(dict):
         self._existing = state
 
 
-def md5(data=b'', **kwargs):
-    """Wrapper around hashlib.md5
+def _md5(data=b'', **_kw):
+    """Deprecated wrapper around hashlib.md5
 
-    Attempt call with 'usedforsecurity=False' if supported.
+    To be removed in Sphinx 9.0
     """
+    return hashlib.md5(data, usedforsecurity=False)
 
-    if sys.version_info[:2] > (3, 8):
-        return hashlib.md5(data, usedforsecurity=False)
-    return hashlib.md5(data, **kwargs)
 
+def _sha1(data=b'', **_kw):
+    """Deprecated wrapper around hashlib.sha1
 
-def sha1(data=b'', **kwargs):
-    """Wrapper around hashlib.sha1
-
-    Attempt call with 'usedforsecurity=False' if supported.
+    To be removed in Sphinx 9.0
     """
-
-    if sys.version_info[:2] > (3, 8):
-        return hashlib.sha1(data, usedforsecurity=False)
-    return hashlib.sha1(data, **kwargs)
+    return hashlib.sha1(data, usedforsecurity=False)
 
 
 class DownloadFiles(dict):
@@ -136,7 +129,7 @@ class DownloadFiles(dict):
 
     def add_file(self, docname: str, filename: str) -> str:
         if filename not in self:
-            digest = md5(filename.encode()).hexdigest()
+            digest = hashlib.md5(filename.encode(), usedforsecurity=False).hexdigest()
             dest = f'{digest}/{os.path.basename(filename)}'
             self[filename] = (set(), dest)
 
@@ -155,23 +148,6 @@ class DownloadFiles(dict):
                 self.add_file(docname, filename)
 
 
-def get_full_modname(modname: str, attribute: str) -> str | None:
-    if modname is None:
-        # Prevents a TypeError: if the last getattr() call will return None
-        # then it's better to return it directly
-        return None
-    module = import_module(modname)
-
-    # Allow an attribute to have multiple parts and incidentally allow
-    # repeated .s in the attribute.
-    value = module
-    for attr in attribute.split('.'):
-        if attr:
-            value = getattr(value, attr)
-
-    return getattr(value, '__module__', None)
-
-
 # a regex to recognize coding cookies
 _coding_re = re.compile(r'coding[:=]\s*([-\w.]+)')
 
@@ -238,36 +214,13 @@ def parselinenos(spec: str, total: int) -> list[int]:
                 items.extend(range(start - 1, end))
             else:
                 raise ValueError
-        except Exception as exc:
-            raise ValueError('invalid line number spec: %r' % spec) from exc
+        except ValueError as exc:
+            msg = f'invalid line number spec: {spec!r}'
+            raise ValueError(msg) from exc
 
     return items
 
 
-def split_into(n: int, type: str, value: str) -> list[str]:
-    """Split an index entry into a given number of parts at semicolons."""
-    parts = [x.strip() for x in value.split(';', n - 1)]
-    if len(list(filter(None, parts))) < n:
-        raise ValueError(f'invalid {type} index entry {value!r}')
-    return parts
-
-
-def split_index_msg(entry_type: str, value: str) -> list[str]:
-    # new entry types must be listed in util/nodes.py!
-    if entry_type == 'single':
-        try:
-            return split_into(2, 'single', value)
-        except ValueError:
-            return split_into(1, 'single', value)
-    if entry_type == 'pair':
-        return split_into(2, 'pair', value)
-    if entry_type == 'triple':
-        return split_into(3, 'triple', value)
-    if entry_type in {'see', 'seealso'}:
-        return split_into(2, 'see', value)
-    raise ValueError(f'invalid {entry_type} index entry {value!r}')
-
-
 def import_object(objname: str, source: str | None = None) -> Any:
     """Import python object by qualname."""
     try:
@@ -289,36 +242,6 @@ def import_object(objname: str, source: str | None = None) -> Any:
         raise ExtensionError('Could not import %s' % objname, exc) from exc
 
 
-def split_full_qualified_name(name: str) -> tuple[str | None, str]:
-    """Split full qualified name to a pair of modname and qualname.
-
-    A qualname is an abbreviation for "Qualified name" introduced at PEP-3155
-    (https://peps.python.org/pep-3155/).  It is a dotted path name
-    from the module top-level.
-
-    A "full" qualified name means a string containing both module name and
-    qualified name.
-
-    .. note:: This function actually imports the module to check its existence.
-              Therefore you need to mock 3rd party modules if needed before
-              calling this function.
-    """
-    parts = name.split('.')
-    for i, _part in enumerate(parts, 1):
-        try:
-            modname = ".".join(parts[:i])
-            import_module(modname)
-        except ImportError:
-            if parts[:i - 1]:
-                return ".".join(parts[:i - 1]), ".".join(parts[i - 1:])
-            else:
-                return None, ".".join(parts)
-        except IndexError:
-            pass
-
-    return name, ""
-
-
 def encode_uri(uri: str) -> str:
     split = list(urlsplit(uri))
     split[1] = split[1].encode('idna').decode('ascii')
@@ -354,12 +277,18 @@ _DEPRECATED_OBJECTS = {
     'format_exception_cut_frames': (_exceptions.format_exception_cut_frames,
                                     'sphinx.exceptions.format_exception_cut_frames'),
     'xmlname_checker': (_xml_name_checker, 'sphinx.builders.epub3._XML_NAME_PATTERN'),
+    'split_index_msg': (_index_entries.split_index_msg,
+                        'sphinx.util.index_entries.split_index_msg'),
+    'split_into': (_index_entries.split_index_msg, 'sphinx.util.index_entries.split_into'),
+    'md5': (_md5, ''),
+    'sha1': (_sha1, ''),
 }
 
 
 def __getattr__(name):
     if name not in _DEPRECATED_OBJECTS:
-        raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+        msg = f'module {__name__!r} has no attribute {name!r}'
+        raise AttributeError(msg)
 
     from sphinx.deprecation import _deprecation_warning
 

sphinx/util/cfamily.py

@@ -4,15 +4,18 @@ from __future__ import annotations
 
 import re
 from copy import deepcopy
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
 from docutils import nodes
-from docutils.nodes import TextElement
 
 from sphinx import addnodes
-from sphinx.config import Config
 from sphinx.util import logging
 
+if TYPE_CHECKING:
+    from docutils.nodes import TextElement
+
+    from sphinx.config import Config
+
 logger = logging.getLogger(__name__)
 
 StringifyTransform = Callable[[Any], str]
@@ -281,7 +284,7 @@ class BaseParser:
     def status(self, msg: str) -> None:
         # for debugging
         indicator = '-' * self.pos + '^'
-        print(f"{msg}\n{self.definition}\n{indicator}")
+        logger.debug(f"{msg}\n{self.definition}\n{indicator}")  # NoQA: G004
 
     def fail(self, msg: str) -> None:
         errors = []

sphinx/util/display.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import functools
-from typing import Any, Callable, Iterable, Iterator, TypeVar
+from typing import Any, Callable, TypeVar
 
 from sphinx.locale import __
 from sphinx.util import logging
-from sphinx.util.console import bold  # type: ignore
+from sphinx.util.console import bold  # type: ignore[attr-defined]
 
 if False:
+    from collections.abc import Iterable, Iterator
     from types import TracebackType
 
 logger = logging.getLogger(__name__)

sphinx/util/docfields.py

@@ -6,21 +6,22 @@ be domain-specifically transformed to a more appealing presentation.
 from __future__ import annotations
 
 import contextlib
-from typing import TYPE_CHECKING, Any, List, Tuple, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from docutils import nodes
 from docutils.nodes import Element, Node
-from docutils.parsers.rst.states import Inliner
 
 from sphinx import addnodes
-from sphinx.environment import BuildEnvironment
 from sphinx.locale import __
 from sphinx.util import logging
 from sphinx.util.nodes import get_node_line
-from sphinx.util.typing import TextlikeNode
 
 if TYPE_CHECKING:
+    from docutils.parsers.rst.states import Inliner
+
     from sphinx.directives import ObjectDescription
+    from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import TextlikeNode
 
 logger = logging.getLogger(__name__)
 
@@ -294,7 +295,7 @@ class DocFieldTransformer:
         types: dict[str, dict] = {}
 
         # step 1: traverse all fields and collect field types and content
-        for field in cast(List[nodes.field], node):
+        for field in cast(list[nodes.field], node):
             assert len(field) == 2
             field_name = cast(nodes.field_name, field[0])
             field_body = cast(nodes.field_body, field[1])
@@ -378,7 +379,7 @@ class DocFieldTransformer:
             # get one entry per field
             if typedesc.is_grouped:
                 if typename in groupindices:
-                    group = cast(Tuple[Field, List, Node], entries[groupindices[typename]])
+                    group = cast(tuple[Field, list, Node], entries[groupindices[typename]])
                 else:
                     groupindices[typename] = len(entries)
                     group = (typedesc, [], field)

sphinx/util/docstrings.py

@@ -10,7 +10,7 @@ from docutils.parsers.rst.states import Body
 field_list_item_re = re.compile(Body.patterns['field_marker'])
 
 
-def separate_metadata(s: str) -> tuple[str, dict[str, str]]:
+def separate_metadata(s: str | None) -> tuple[str | None, dict[str, str]]:
     """Separate docstring into metadata and others."""
     in_other_element = False
     metadata: dict[str, str] = {}

sphinx/util/docutils.py

@@ -4,17 +4,17 @@ from __future__ import annotations
 
 import os
 import re
+from collections.abc import Sequence  # NoQA: TCH003
 from contextlib import contextmanager
 from copy import copy
 from os import path
-from typing import IO, TYPE_CHECKING, Any, Callable, Generator, cast
+from typing import IO, TYPE_CHECKING, Any, Callable, cast
 
 import docutils
 from docutils import nodes
 from docutils.io import FileOutput
-from docutils.nodes import Element, Node, system_message
 from docutils.parsers.rst import Directive, directives, roles
-from docutils.parsers.rst.states import Inliner
+from docutils.parsers.rst.states import Inliner  # NoQA: TCH002
 from docutils.statemachine import State, StateMachine, StringList
 from docutils.utils import Reporter, unescape
 from docutils.writers._html_base import HTMLTranslator
@@ -22,19 +22,21 @@ from docutils.writers._html_base import HTMLTranslator
 from sphinx.errors import SphinxError
 from sphinx.locale import _, __
 from sphinx.util import logging
-from sphinx.util.typing import RoleFunction
 
 logger = logging.getLogger(__name__)
 report_re = re.compile('^(.+?:(?:\\d+)?): \\((DEBUG|INFO|WARNING|ERROR|SEVERE)/(\\d+)?\\) ')
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
     from types import ModuleType
 
     from docutils.frontend import Values
+    from docutils.nodes import Element, Node, system_message
 
     from sphinx.builders import Builder
     from sphinx.config import Config
     from sphinx.environment import BuildEnvironment
+    from sphinx.util.typing import RoleFunction
 
 # deprecated name -> (object to return, canonical path or empty string)
 _DEPRECATED_OBJECTS = {
@@ -44,7 +46,8 @@ _DEPRECATED_OBJECTS = {
 
 def __getattr__(name):
     if name not in _DEPRECATED_OBJECTS:
-        raise AttributeError(f'module {__name__!r} has no attribute {name!r}')
+        msg = f'module {__name__!r} has no attribute {name!r}'
+        raise AttributeError(msg)
 
     from sphinx.deprecation import _deprecation_warning
 
@@ -60,13 +63,13 @@ additional_nodes: set[type[Element]] = set()
 def docutils_namespace() -> Generator[None, None, None]:
     """Create namespace for reST parsers."""
     try:
-        _directives = copy(directives._directives)  # type: ignore
-        _roles = copy(roles._roles)  # type: ignore
+        _directives = copy(directives._directives)  # type: ignore[attr-defined]
+        _roles = copy(roles._roles)  # type: ignore[attr-defined]
 
         yield
     finally:
-        directives._directives = _directives  # type: ignore
-        roles._roles = _roles  # type: ignore
+        directives._directives = _directives  # type: ignore[attr-defined]
+        roles._roles = _roles  # type: ignore[attr-defined]
 
         for node in list(additional_nodes):
             unregister_node(node)
@@ -75,7 +78,7 @@ def docutils_namespace() -> Generator[None, None, None]:
 
 def is_directive_registered(name: str) -> bool:
     """Check the *name* directive is already registered."""
-    return name in directives._directives  # type: ignore
+    return name in directives._directives  # type: ignore[attr-defined]
 
 
 def register_directive(name: str, directive: type[Directive]) -> None:
@@ -89,7 +92,7 @@ def register_directive(name: str, directive: type[Directive]) -> None:
 
 def is_role_registered(name: str) -> bool:
     """Check the *name* role is already registered."""
-    return name in roles._roles  # type: ignore
+    return name in roles._roles  # type: ignore[attr-defined]
 
 
 def register_role(name: str, role: RoleFunction) -> None:
@@ -103,7 +106,7 @@ def register_role(name: str, role: RoleFunction) -> None:
 
 def unregister_role(name: str) -> None:
     """Unregister a role from docutils."""
-    roles._roles.pop(name, None)  # type: ignore
+    roles._roles.pop(name, None)  # type: ignore[attr-defined]
 
 
 def is_node_registered(node: type[Element]) -> bool:
@@ -118,7 +121,7 @@ def register_node(node: type[Element]) -> None:
     inside ``docutils_namespace()`` to prevent side-effects.
     """
     if not hasattr(nodes.GenericNodeVisitor, 'visit_' + node.__name__):
-        nodes._add_node_class_names([node.__name__])  # type: ignore
+        nodes._add_node_class_names([node.__name__])  # type: ignore[attr-defined]
         additional_nodes.add(node)
 
 
@@ -275,7 +278,8 @@ class CustomReSTDispatcher:
     def role(
         self, role_name: str, language_module: ModuleType, lineno: int, reporter: Reporter,
     ) -> tuple[RoleFunction, list[system_message]]:
-        return self.role_func(role_name, language_module, lineno, reporter)
+        return self.role_func(role_name, language_module,  # type: ignore[return-value]
+                              lineno, reporter)
 
 
 class ElementLookupError(Exception):
@@ -375,17 +379,17 @@ def switch_source_input(state: State, content: StringList) -> Generator[None, No
     """Switch current source input of state temporarily."""
     try:
         # remember the original ``get_source_and_line()`` method
-        get_source_and_line = state.memo.reporter.get_source_and_line  # type: ignore
+        gsal = state.memo.reporter.get_source_and_line  # type: ignore[attr-defined]
 
         # replace it by new one
         state_machine = StateMachine([], None)  # type: ignore[arg-type]
         state_machine.input_lines = content
-        state.memo.reporter.get_source_and_line = state_machine.get_source_and_line  # type: ignore  # noqa: E501
+        state.memo.reporter.get_source_and_line = state_machine.get_source_and_line  # type: ignore[attr-defined]  # noqa: E501
 
         yield
     finally:
         # restore the method
-        state.memo.reporter.get_source_and_line = get_source_and_line  # type: ignore
+        state.memo.reporter.get_source_and_line = gsal  # type: ignore[attr-defined]
 
 
 class SphinxFileOutput(FileOutput):
@@ -447,24 +451,26 @@ class SphinxRole:
     .. note:: The subclasses of this class might not work with docutils.
               This class is strongly coupled with Sphinx.
     """
-    name: str           #: The role name actually used in the document.
-    rawtext: str        #: A string containing the entire interpreted text input.
-    text: str           #: The interpreted text content.
-    lineno: int         #: The line number where the interpreted text begins.
-    inliner: Inliner    #: The ``docutils.parsers.rst.states.Inliner`` object.
-    options: dict       #: A dictionary of directive options for customization
-                        #: (from the "role" directive).
-    content: list[str]  #: A list of strings, the directive content for customization
-                        #: (from the "role" directive).
+    name: str         #: The role name actually used in the document.
+    rawtext: str      #: A string containing the entire interpreted text input.
+    text: str         #: The interpreted text content.
+    lineno: int       #: The line number where the interpreted text begins.
+    inliner: Inliner  #: The ``docutils.parsers.rst.states.Inliner`` object.
+    #: A dictionary of directive options for customisation
+    #: (from the "role" directive).
+    options: dict[str, Any]
+    #: A list of strings, the directive content for customisation
+    #: (from the "role" directive).
+    content: Sequence[str]
 
     def __call__(self, name: str, rawtext: str, text: str, lineno: int,
-                 inliner: Inliner, options: dict = {}, content: list[str] = [],
+                 inliner: Inliner, options: dict | None = None, content: Sequence[str] = (),
                  ) -> tuple[list[Node], list[system_message]]:
         self.rawtext = rawtext
         self.text = unescape(text)
         self.lineno = lineno
         self.inliner = inliner
-        self.options = options
+        self.options = options if options is not None else {}
         self.content = content
 
         # guess role type
@@ -475,7 +481,8 @@ class SphinxRole:
             if not self.name:
                 self.name = self.env.config.default_role
             if not self.name:
-                raise SphinxError('cannot determine default role!')
+                msg = 'cannot determine default role!'
+                raise SphinxError(msg)
 
         return self.run()
 
@@ -495,7 +502,7 @@ class SphinxRole:
     def get_source_info(self, lineno: int | None = None) -> tuple[str, int]:
         if lineno is None:
             lineno = self.lineno
-        return self.inliner.reporter.get_source_and_line(lineno)  # type: ignore
+        return self.inliner.reporter.get_source_and_line(lineno)  # type: ignore[attr-defined]
 
     def set_source_info(self, node: Node, lineno: int | None = None) -> None:
         node.source, node.line = self.get_source_info(lineno)
@@ -521,8 +528,11 @@ class ReferenceRole(SphinxRole):
     explicit_title_re = re.compile(r'^(.+?)\s*(?<!\x00)<(.*?)>$', re.DOTALL)
 
     def __call__(self, name: str, rawtext: str, text: str, lineno: int,
-                 inliner: Inliner, options: dict = {}, content: list[str] = [],
+                 inliner: Inliner, options: dict | None = None, content: Sequence[str] = (),
                  ) -> tuple[list[Node], list[system_message]]:
+        if options is None:
+            options = {}
+
         # if the first character is a bang, don't cross-reference at all
         self.disabled = text.startswith('!')
 

sphinx/util/fileutil.py

@@ -9,13 +9,13 @@ from typing import TYPE_CHECKING, Callable
 from docutils.utils import relative_path
 
 from sphinx.util.osutil import copyfile, ensuredir
-from sphinx.util.typing import PathMatcher
 
 if TYPE_CHECKING:
     from sphinx.util.template import BaseRenderer
+    from sphinx.util.typing import PathMatcher
 
 
-def copy_asset_file(source: str, destination: str,
+def copy_asset_file(source: str | os.PathLike[str], destination: str | os.PathLike[str],
                     context: dict | None = None,
                     renderer: BaseRenderer | None = None) -> None:
     """Copy an asset file to destination.
@@ -34,14 +34,16 @@ def copy_asset_file(source: str, destination: str,
     if os.path.isdir(destination):
         # Use source filename if destination points a directory
         destination = os.path.join(destination, os.path.basename(source))
+    else:
+        destination = str(destination)
 
-    if source.lower().endswith('_t') and context is not None:
+    if os.path.basename(source).endswith(('_t', '_T')) and context is not None:
         if renderer is None:
             from sphinx.util.template import SphinxRenderer
             renderer = SphinxRenderer()
 
         with open(source, encoding='utf-8') as fsrc:
-            if destination.lower().endswith('_t'):
+            if destination.endswith(('_t', '_T')):
                 destination = destination[:-2]
             with open(destination, 'w', encoding='utf-8') as fdst:
                 fdst.write(renderer.render_string(fsrc.read(), context))
@@ -49,7 +51,8 @@ def copy_asset_file(source: str, destination: str,
         copyfile(source, destination)
 
 
-def copy_asset(source: str, destination: str, excluded: PathMatcher = lambda path: False,
+def copy_asset(source: str | os.PathLike[str], destination: str | os.PathLike[str],
+               excluded: PathMatcher = lambda path: False,
                context: dict | None = None, renderer: BaseRenderer | None = None,
                onerror: Callable[[str, Exception], None] | None = None) -> None:
     """Copy asset files to destination recursively.
@@ -77,7 +80,7 @@ def copy_asset(source: str, destination: str, excluded: PathMatcher = lambda pat
         return
 
     for root, dirs, files in os.walk(source, followlinks=True):
-        reldir = relative_path(source, root)
+        reldir = relative_path(source, root)  # type: ignore[arg-type]
         for dir in dirs[:]:
             if excluded(posixpath.join(reldir, dir)):
                 dirs.remove(dir)