8310891141

Committed 16 Mar 2024 10:28PM UTC coverage: 73.102% (-0.04%) from 73.144%

Build # 8310891141

Build Type

push

github

Committed by

mborsetti

Commit Message

Version 3.20.2

Run Details

1466 of 2273 branches covered (64.5%)

Branch coverage included in aggregate %.

1 of 3 new or added lines in 2 files covered. (33.33%)

3 existing lines in 2 files now uncovered.

3733 of 4839 relevant lines covered (77.14%)

6.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.95

/webchanges/util.py

"""A few utilities used elsewhere."""

# The code below is subject to the license contained in the LICENSE file, which is part of the source code.

from __future__ import annotations

import getpass
import html
import importlib.machinery
import importlib.util
import logging
import os
import re
import shlex
import stat
import subprocess  # noqa: S404 Consider possible security implications associated with the subprocess module.
import sys
import textwrap
from math import floor, log10
from os import PathLike
from pathlib import Path
from types import ModuleType
from typing import Callable, Match, Optional, Union

try:
    import httpx
except ImportError:
    httpx = None  # type: ignore[assignment]

try:
    import h2
except ImportError:
    h2 = None  # type: ignore[assignment]

from webchanges import __project_name__, __version__

try:
    from packaging.version import parse as parse_version
except ImportError:
    from webchanges._vendored.packaging_version import parse as parse_version  # type: ignore[assignment]

logger = logging.getLogger(__name__)


class TrackSubClasses(type):
    """A metaclass that stores subclass name-to-class mappings in the base class."""

    # __subclasses__ gets redefined from default "Callable[[_TT], list[_TT]]
    __subclasses__: dict[str, TrackSubClasses]  # type: ignore[assignment]
    __anonymous_subclasses__: list[TrackSubClasses]
    __required__: tuple[str, ...] = ()
    __optional__: tuple[str, ...] = ()

    __kind__: str
    __supported_subfilters__: dict[str, str]

    @staticmethod
    def sorted_by_kind(cls: TrackSubClasses) -> list[TrackSubClasses]:
        """Generates a list of all members of a class sorted by the value of their __kind__ attribute. Useful for
        documentation.

        :param cls: The class.
        :return: The sorted list of class members.
        """
        return [item for _, item in sorted((it.__kind__, it) for it in cls.__subclasses__.values() if it.__kind__)]

    def __init__(cls, name: str, bases: tuple[type, ...], namespace: dict) -> None:
        for base in bases:
            if base == object:
                continue

            for attr in {'__required__', '__optional__'}:
                if not hasattr(base, attr):
                    continue

                inherited = getattr(base, attr, ())
                new_value = tuple(namespace.get(attr, ())) + tuple(inherited)
                namespace[attr] = new_value
                setattr(cls, attr, new_value)

        for base in bases:
            if base == object:
                continue

            if hasattr(cls, '__kind__'):
                subclasses = getattr(base, '__subclasses__', None)
                if subclasses is not None:
                    logger.debug(f'Registering {cls} as {cls.__kind__}')
                    subclasses[cls.__kind__] = cls
                    break
            else:
                anonymous_subclasses = getattr(base, '__anonymous_subclasses__', None)
                if anonymous_subclasses is not None:
                    logger.debug(f'Registering {cls}')
                    anonymous_subclasses.append(cls)
                    break

        super().__init__(name, bases, namespace)


def edit_file(filename: Union[str, bytes, PathLike]) -> None:
    """Opens the editor to edit a file.

    :param filename: The filename.
    """
    editor = os.environ.get('EDITOR', None)
    if not editor:
        editor = os.environ.get('VISUAL', None)
    if not editor:
        if os.name == 'nt':
            editor = 'notepad.exe'
        else:
            print('Please set the path to the editor in the environment variable $EDITOR, e.g. "export EDITOR=nano"')
            raise SystemExit(1)

    subprocess.run(  # noqa: S603 subprocess call - check for execution of untrusted input.
        shlex.split(editor) + [str(filename)],
        check=True,
    )


def import_module_from_source(module_name: str, source_path: Union[str, bytes, PathLike]) -> ModuleType:
    """Loads a module and executes it in its own namespace.

    :param module_name: The name of the module to import.
    :param source_path: The path where the module is located.
    :return: A ModuleType object.
    """
    source_path = str(source_path)
    loader = importlib.machinery.SourceFileLoader(module_name, source_path)
    spec = importlib.util.spec_from_file_location(module_name, source_path, loader=loader)
    module = importlib.util.module_from_spec(spec)  # type: ignore[arg-type]
    sys.modules[module_name] = module
    try:
        loader.exec_module(module)
    except Exception:
        sys.tracebacklimit = 1000
        raise
    return module


def chunk_string(text: str, length: int, numbering: bool = False) -> list[str]:
    """Chunks a string.

    :param text: The text to be chunked.
    :param length: The length of the chunked text.
    :param numbering: Whether to number each chunk on the left if more than one chunk is generated.

    :returns: a list of chunked strings
    """
    if numbering and len(text) > length:
        try:
            text_length = length - 4 - 2
            digits_try = 1 if text_length <= 0 else floor(log10(len(text) / text_length))  # initialization floor
            digits_guess = digits_try + 1
            while digits_guess > digits_try:
                digits_try += 1
                text_length = length - 4 - 2 * digits_try
                if text_length <= 0:
                    raise ValueError('Not enough space to chunkify string with line numbering (1)')
                lines_guess = len(text) / text_length
                digits_guess = floor(log10(lines_guess)) + 1

            chunks = textwrap.wrap(text, text_length, replace_whitespace=False)
            actual_digits = floor(log10(len(chunks))) + 1
            while actual_digits > digits_try:
                digits_try += 1
                text_length = length - 4 - 2 * digits_try
                if text_length <= 0:
                    raise ValueError('Not enough space to chunkify string with line numbering (2)')
                chunks = textwrap.wrap(text, text_length, replace_whitespace=False)
                actual_digits = floor(log10(len(chunks))) + 1

            length = len(chunks)
            return [line + ' (' + f'{{:{digits_try}d}}'.format(i + 1) + f'/{length})' for i, line in enumerate(chunks)]

        except ValueError as e:
            logger.error(f'{e}')

    return textwrap.wrap(text, length, replace_whitespace=False)


def linkify(
    text: str,
    shorten: bool = False,
    extra_params: Union[str, Callable[[str], str]] = '',
    require_protocol: bool = False,
    permitted_protocols: tuple[str, ...] = (
        'http',
        'https',
        'mailto',
    ),
) -> str:
    """Converts plain text into HTML with links.

    For example linkify("Hello http://tornadoweb.org!") would return 'Hello
    <a href="http://tornadoweb.org">http://tornadoweb.org</a>!'.

    We are using a regex from tornado library https://github.com/tornadoweb/tornado/blob/master/tornado/escape.py.
    This regex should avoid character entities other than &amp; so that we won't pick up &quot;, etc., but it is
    vulnerable to Regular expression Denial of Service (ReDoS), which would divert computational resources to an
    expensive regex match. The risk in this application is limited.

    In the future, consider using linkify from the bleach project instead (requires importing another package).

    :parameter text: The text to linkify.
    :parameter shorten: Long urls will be shortened for display.
    :parameter extra_params: Extra text to include in the link tag, or a callable taking the link as an argument and
        returning the extra text, e.g. linkify(text, extra_params='rel="nofollow" class="external"').
    :parameter require_protocol: Only linkify urls which include a protocol; if this is False, urls such as
        www.facebook.com will also be linkified.
    :parameter permitted_protocols: Protocols which should be linkified, e.g. linkify(text,
        permitted_protocols=('http', 'ftp', 'mailto')); it is very unsafe to include protocols such as javascript.
    """
    _URL_RE = re.compile(
        r"""\b((?:([\w-]+):(/{1,3})|www[.])(?:(?:(?:[^\s&()]|
    &amp;|&quot;)*(?:[^!"#$%&'()*+,.:;<=>?@\[\]^`{|}~\s]))|(?:\((?:[^\s&()]|&amp;|
    &quot;)*\)))+)"""
    )  # noqa: DUO138 catastrophic "re" usage - denial-of-service possible.

    if extra_params and not callable(extra_params):
        extra_params = f' {extra_params.strip()}'

    def make_link(m: Match) -> str:
        """Replacement function for re.sub using re.match as input to convert plain text into HTML with links."""
        url: str = m.group(1)
        proto: str = m.group(2)
        if require_protocol and not proto:
            return url  # not protocol, no linkify

        if proto and proto not in permitted_protocols:
            return url  # bad protocol, no linkify

        href: str = m.group(1)
        if not proto:
            href = f'https://{href}'  # no proto specified, use https

        if callable(extra_params):
            params = f' {extra_params(href).strip()}'
        else:
            params = extra_params

        # clip long urls. max_len is just an approximation
        max_len = 30
        if shorten and len(url) > max_len:
            before_clip = url
            if proto:
                proto_len = len(proto) + 1 + len(m.group(3) or '')  # +1 for :
            else:
                proto_len = 0

            parts = url[proto_len:].split('/')
            if len(parts) > 1:
                # Grab the whole host part plus the first bit of the path
                # The path is usually not that interesting once shortened
                # (no more slug, etc), so it really just provides a little
                # extra indication of shortening.
                url = url[:proto_len] + parts[0] + '/' + parts[1][:8].split('?')[0].split('.')[0]

            if len(url) > max_len * 1.5:  # still too long
                url = url[:max_len]

            if url != before_clip:
                amp = url.rfind('&')
                # avoid splitting html char entities
                if amp > max_len - 5:
                    url = url[:amp]
                url += '...'

                if len(url) >= len(before_clip):
                    url = before_clip
                else:
                    # full url is visible on mouse-over (for those who don't
                    # have a status bar, such as Safari by default)
                    params += f' title={href}'

        return f'<a href="{href}"{params}>{url}</a>'

    text = html.escape(text)
    return _URL_RE.sub(make_link, text)


def get_new_version_number(timeout: Optional[float] = None) -> Union[str, bool]:
    """Check PyPi for newer version of project.

    :parameter timeout: Timeout in seconds after which empty string is returned.
    :returns: The new version number if a newer version of project is found on PyPi, empty string otherwise, False if
      error retrieving the new version number is encountered.
    """
    if httpx is None:
        logger.info('Cannot query PyPi for latest release: HTTPX not installed')
        return ''

    try:
        r = httpx.Client(http2=h2 is not None).get(f'https://pypi.org/pypi/{__project_name__}/json', timeout=timeout)
    except httpx.RequestError as e:
        logger.info(f'Exception when querying PyPi for latest release: {e}')
        return False

    if r.is_success:
        latest_release: str = r.json()['info']['version']
        if parse_version(latest_release) > parse_version(__version__):
            return latest_release
    else:
        logger.info(f'HTTP error when querying PyPi for latest release: {r}')

    return ''


def dur_text(duration: float) -> str:
    """Returns a formatted string optimized to the number of seconds for use in footers.

    :parameter duration: The duration in seconds.
    :returns: The formatted string.
    """
    if duration < 60:
        return f'{float(f"{duration:.2g}"):g} seconds'
    else:
        m, s = divmod(duration, 60)
        return f'{m:.0f}:{s:02.0f}'


def file_ownership_checks(filename: Path) -> list[str]:
    """Check security of file and its directory, i.e. that they belong to the current UID and only the owner
    can write to them. Return list of errors if any. Linux only.

    :returns: List of errors encountered (if any).
    """

    if os.name == 'nt':
        return []

    file_ownership_errors = []
    current_uid = os.getuid()  # type: ignore[attr-defined]  # not defined in Windows

    dirname = filename.parent
    dir_st = dirname.stat()
    if (dir_st.st_mode & (stat.S_IWGRP | stat.S_IWOTH)) != 0:
        file_ownership_errors.append(f'{dirname} is group/world-writable')
    if dir_st.st_uid != current_uid:
        file_ownership_errors.append(f'{dirname} not owned by {getpass.getuser()}')

    file_st = filename.stat()
    if (file_st.st_mode & (stat.S_IWGRP | stat.S_IWOTH)) != 0:
        file_ownership_errors.append(f'{filename} is group/world-writable')
    if file_st.st_uid != current_uid:
        file_ownership_errors.append(f'{filename} not owned by {getpass.getuser()}')

    return file_ownership_errors

1	"""A few utilities used elsewhere."""
2
3	# The code below is subject to the license contained in the LICENSE file, which is part of the source code.
4
5	from __future__ import annotations	8✔
6
7	import getpass	8✔
8	import html	8✔
9	import importlib.machinery	8✔
10	import importlib.util	8✔
11	import logging	8✔
12	import os	8✔
13	import re	8✔
14	import shlex	8✔
15	import stat	8✔
16	import subprocess # noqa: S404 Consider possible security implications associated with the subprocess module.	8✔
17	import sys	8✔
18	import textwrap	8✔
19	from math import floor, log10	8✔
20	from os import PathLike	8✔
21	from pathlib import Path	8✔
22	from types import ModuleType	8✔
23	from typing import Callable, Match, Optional, Union	8✔
24
25	try:	8✔
26	import httpx	8✔
27	except ImportError:
28	httpx = None # type: ignore[assignment]
29
30	try:	8✔
31	import h2	8✔
32	except ImportError:
33	h2 = None # type: ignore[assignment]
34
35	from webchanges import __project_name__, __version__	8✔
36
37	try:	8✔
38	from packaging.version import parse as parse_version	8✔
39	except ImportError:
40	from webchanges._vendored.packaging_version import parse as parse_version # type: ignore[assignment]
41
42	logger = logging.getLogger(__name__)	8✔
43
44
45	class TrackSubClasses(type):	8✔
46	"""A metaclass that stores subclass name-to-class mappings in the base class."""
47
48	# __subclasses__ gets redefined from default "Callable[[_TT], list[_TT]]
49	__subclasses__: dict[str, TrackSubClasses] # type: ignore[assignment]	8✔
50	__anonymous_subclasses__: list[TrackSubClasses]	8✔
51	__required__: tuple[str, ...] = ()	8✔
52	__optional__: tuple[str, ...] = ()	8✔
53
54	__kind__: str	8✔
55	__supported_subfilters__: dict[str, str]	8✔
56
57	@staticmethod	8✔
58	def sorted_by_kind(cls: TrackSubClasses) -> list[TrackSubClasses]:	8✔
59	"""Generates a list of all members of a class sorted by the value of their __kind__ attribute. Useful for
60	documentation.
61
62	:param cls: The class.
63	:return: The sorted list of class members.
64	"""
65	return [item for _, item in sorted((it.__kind__, it) for it in cls.__subclasses__.values() if it.__kind__)]	8✔
66
67	def __init__(cls, name: str, bases: tuple[type, ...], namespace: dict) -> None:	8✔
68	for base in bases:	8✔
69	if base == object:	8!
70	continue	×
71
72	for attr in {'__required__', '__optional__'}:	8✔
73	if not hasattr(base, attr):	8!
74	continue	×
75
76	inherited = getattr(base, attr, ())	8✔
77	new_value = tuple(namespace.get(attr, ())) + tuple(inherited)	8✔
78	namespace[attr] = new_value	8✔
79	setattr(cls, attr, new_value)	8✔
80
81	for base in bases:	8✔
82	if base == object:	8!
83	continue	×
84
85	if hasattr(cls, '__kind__'):	8!
86	subclasses = getattr(base, '__subclasses__', None)	8✔
87	if subclasses is not None:	8!
88	logger.debug(f'Registering {cls} as {cls.__kind__}')	8✔
89	subclasses[cls.__kind__] = cls	8✔
90	break	8✔
91	else:
92	anonymous_subclasses = getattr(base, '__anonymous_subclasses__', None)	×
93	if anonymous_subclasses is not None:	×
94	logger.debug(f'Registering {cls}')	×
95	anonymous_subclasses.append(cls)	×
96	break	×
97
98	super().__init__(name, bases, namespace)	8✔
99
100
101	def edit_file(filename: Union[str, bytes, PathLike]) -> None:	8✔
102	"""Opens the editor to edit a file.
103
104	:param filename: The filename.
105	"""
106	editor = os.environ.get('EDITOR', None)	8✔
107	if not editor:	8✔
108	editor = os.environ.get('VISUAL', None)	8✔
109	if not editor:	8!
110	if os.name == 'nt':	×
111	editor = 'notepad.exe'	×
112	else:
113	print('Please set the path to the editor in the environment variable $EDITOR, e.g. "export EDITOR=nano"')	×
114	raise SystemExit(1)	×
115
116	subprocess.run( # noqa: S603 subprocess call - check for execution of untrusted input.	8✔
117	shlex.split(editor) + [str(filename)],
118	check=True,
119	)
120
121
122	def import_module_from_source(module_name: str, source_path: Union[str, bytes, PathLike]) -> ModuleType:	8✔
123	"""Loads a module and executes it in its own namespace.
124
125	:param module_name: The name of the module to import.
126	:param source_path: The path where the module is located.
127	:return: A ModuleType object.
128	"""
129	source_path = str(source_path)	8✔
130	loader = importlib.machinery.SourceFileLoader(module_name, source_path)	8✔
131	spec = importlib.util.spec_from_file_location(module_name, source_path, loader=loader)	8✔
132	module = importlib.util.module_from_spec(spec) # type: ignore[arg-type]	8✔
133	sys.modules[module_name] = module	8✔
134	try:	8✔
135	loader.exec_module(module)	8✔
136	except Exception:	×
137	sys.tracebacklimit = 1000	×
138	raise	×
139	return module	8✔
140
141
142	def chunk_string(text: str, length: int, numbering: bool = False) -> list[str]:	8✔
143	"""Chunks a string.
144
145	:param text: The text to be chunked.
146	:param length: The length of the chunked text.
147	:param numbering: Whether to number each chunk on the left if more than one chunk is generated.
148
149	:returns: a list of chunked strings
150	"""
151	if numbering and len(text) > length:	8✔
152	try:	8✔
153	text_length = length - 4 - 2	8✔
154	digits_try = 1 if text_length <= 0 else floor(log10(len(text) / text_length)) # initialization floor	8✔
155	digits_guess = digits_try + 1	8✔
156	while digits_guess > digits_try:	8✔
157	digits_try += 1	8✔
158	text_length = length - 4 - 2 * digits_try	8✔
159	if text_length <= 0:	8✔
160	raise ValueError('Not enough space to chunkify string with line numbering (1)')	8✔
161	lines_guess = len(text) / text_length	8✔
162	digits_guess = floor(log10(lines_guess)) + 1	8✔
163
164	chunks = textwrap.wrap(text, text_length, replace_whitespace=False)	8✔
165	actual_digits = floor(log10(len(chunks))) + 1	8✔
166	while actual_digits > digits_try:	8!
167	digits_try += 1	×
168	text_length = length - 4 - 2 * digits_try	×
169	if text_length <= 0:	×
170	raise ValueError('Not enough space to chunkify string with line numbering (2)')	×
171	chunks = textwrap.wrap(text, text_length, replace_whitespace=False)	×
172	actual_digits = floor(log10(len(chunks))) + 1	×
173
174	length = len(chunks)	8✔
175	return [line + ' (' + f'{{:{digits_try}d}}'.format(i + 1) + f'/{length})' for i, line in enumerate(chunks)]	8✔
176
177	except ValueError as e:	8✔
178	logger.error(f'{e}')	8✔
179
180	return textwrap.wrap(text, length, replace_whitespace=False)	8✔
181
182
183	def linkify(	8✔
184	text: str,
185	shorten: bool = False,
186	extra_params: Union[str, Callable[[str], str]] = '',
187	require_protocol: bool = False,
188	permitted_protocols: tuple[str, ...] = (
189	'http',
190	'https',
191	'mailto',
192	),
193	) -> str:
194	"""Converts plain text into HTML with links.
195
196	For example linkify("Hello http://tornadoweb.org!") would return 'Hello
197	<a href="http://tornadoweb.org">http://tornadoweb.org</a>!'.
198
199	We are using a regex from tornado library https://github.com/tornadoweb/tornado/blob/master/tornado/escape.py.
200	This regex should avoid character entities other than & so that we won't pick up ", etc., but it is
201	vulnerable to Regular expression Denial of Service (ReDoS), which would divert computational resources to an
202	expensive regex match. The risk in this application is limited.
203
204	In the future, consider using linkify from the bleach project instead (requires importing another package).
205
206	:parameter text: The text to linkify.
207	:parameter shorten: Long urls will be shortened for display.
208	:parameter extra_params: Extra text to include in the link tag, or a callable taking the link as an argument and
209	returning the extra text, e.g. linkify(text, extra_params='rel="nofollow" class="external"').
210	:parameter require_protocol: Only linkify urls which include a protocol; if this is False, urls such as
211	www.facebook.com will also be linkified.
212	:parameter permitted_protocols: Protocols which should be linkified, e.g. linkify(text,
213	permitted_protocols=('http', 'ftp', 'mailto')); it is very unsafe to include protocols such as javascript.
214	"""
215	_URL_RE = re.compile(	8✔
216	r"""\b((?:([\w-]+):(/{1,3})\|www[.])(?:(?:(?:[^\s&()]\|
217	&\|")(?:[^!"#$%&'()+,.:;<=>?@\[\]^`{\|}~\s]))\|(?:\((?:[^\s&()]\|&\|
218	")*\)))+)"""
219	) # noqa: DUO138 catastrophic "re" usage - denial-of-service possible.
220
221	if extra_params and not callable(extra_params):	8✔
222	extra_params = f' {extra_params.strip()}'	8✔
223
224	def make_link(m: Match) -> str:	8✔
225	"""Replacement function for re.sub using re.match as input to convert plain text into HTML with links."""
226	url: str = m.group(1)	8✔
227	proto: str = m.group(2)	8✔
228	if require_protocol and not proto:	8!
229	return url # not protocol, no linkify	×
230
231	if proto and proto not in permitted_protocols:	8✔
232	return url # bad protocol, no linkify	8✔
233
234	href: str = m.group(1)	8✔
235	if not proto:	8✔
236	href = f'https://{href}' # no proto specified, use https	8✔
237
238	if callable(extra_params):	8!
239	params = f' {extra_params(href).strip()}'	×
240	else:
241	params = extra_params	8✔
242
243	# clip long urls. max_len is just an approximation
244	max_len = 30	8✔
245	if shorten and len(url) > max_len:	8✔
246	before_clip = url	8✔
247	if proto:	8✔
248	proto_len = len(proto) + 1 + len(m.group(3) or '') # +1 for :	8✔
249	else:
250	proto_len = 0	8✔
251
252	parts = url[proto_len:].split('/')	8✔
253	if len(parts) > 1:	8!
254	# Grab the whole host part plus the first bit of the path
255	# The path is usually not that interesting once shortened
256	# (no more slug, etc), so it really just provides a little
257	# extra indication of shortening.
258	url = url[:proto_len] + parts[0] + '/' + parts[1][:8].split('?')[0].split('.')[0]	8✔
259
260	if len(url) > max_len * 1.5: # still too long	8!
261	url = url[:max_len]	×
262
263	if url != before_clip:	8✔
264	amp = url.rfind('&')	8✔
265	# avoid splitting html char entities
266	if amp > max_len - 5:	8!
267	url = url[:amp]	×
268	url += '...'	8✔
269
270	if len(url) >= len(before_clip):	8!
271	url = before_clip	×
272	else:
273	# full url is visible on mouse-over (for those who don't
274	# have a status bar, such as Safari by default)
275	params += f' title={href}'	8✔
276
277	return f'<a href="{href}"{params}>{url}</a>'	8✔
278
279	text = html.escape(text)	8✔
280	return _URL_RE.sub(make_link, text)	8✔
281
282
283	def get_new_version_number(timeout: Optional[float] = None) -> Union[str, bool]:	8✔
284	"""Check PyPi for newer version of project.
285
286	:parameter timeout: Timeout in seconds after which empty string is returned.
287	:returns: The new version number if a newer version of project is found on PyPi, empty string otherwise, False if
288	error retrieving the new version number is encountered.
289	"""
290	if httpx is None:	8!
291	logger.info('Cannot query PyPi for latest release: HTTPX not installed')	×
292	return ''	×
293
294	try:	8✔
295	r = httpx.Client(http2=h2 is not None).get(f'https://pypi.org/pypi/{__project_name__}/json', timeout=timeout)	8✔
296	except httpx.RequestError as e:	×
297	logger.info(f'Exception when querying PyPi for latest release: {e}')	×
298	return False	×
299
300	if r.is_success:	8!
301	latest_release: str = r.json()['info']['version']	8✔
302	if parse_version(latest_release) > parse_version(__version__):	8!
303	return latest_release	×
304	else:
305	logger.info(f'HTTP error when querying PyPi for latest release: {r}')	×
306
307	return ''	8✔
308
309
310	def dur_text(duration: float) -> str:	8✔
311	"""Returns a formatted string optimized to the number of seconds for use in footers.
312
313	:parameter duration: The duration in seconds.
314	:returns: The formatted string.
315	"""
316	if duration < 60:	8!
317	return f'{float(f"{duration:.2g}"):g} seconds'	8✔
318	else:
UNCOV 319	m, s = divmod(duration, 60)	×
UNCOV 320	return f'{m:.0f}:{s:02.0f}'	×
321
322
323	def file_ownership_checks(filename: Path) -> list[str]:	8✔
324	"""Check security of file and its directory, i.e. that they belong to the current UID and only the owner
325	can write to them. Return list of errors if any. Linux only.
326
327	:returns: List of errors encountered (if any).
328	"""
329
330	if os.name == 'nt':	8!
331	return []	×
332
333	file_ownership_errors = []	8✔
334	current_uid = os.getuid() # type: ignore[attr-defined] # not defined in Windows	8✔
335
336	dirname = filename.parent	8✔
337	dir_st = dirname.stat()	8✔
338	if (dir_st.st_mode & (stat.S_IWGRP \| stat.S_IWOTH)) != 0:	8✔
339	file_ownership_errors.append(f'{dirname} is group/world-writable')	4✔
340	if dir_st.st_uid != current_uid:	8✔
341	file_ownership_errors.append(f'{dirname} not owned by {getpass.getuser()}')	4✔
342
343	file_st = filename.stat()	8✔
344	if (file_st.st_mode & (stat.S_IWGRP \| stat.S_IWOTH)) != 0:	8✔
345	file_ownership_errors.append(f'{filename} is group/world-writable')	8✔
346	if file_st.st_uid != current_uid:	8!
347	file_ownership_errors.append(f'{filename} not owned by {getpass.getuser()}')	×
348
349	return file_ownership_errors	8✔

mborsetti / webchanges / 8310891141

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous