6004818396

Committed 28 Aug 2023 08:50PM UTC coverage: 73.233% (-0.05%) from 73.278%

Build # 6004818396

Build Type

push

github

Committed by

mborsetti

Commit Message

Version 3.13

Run Details

1372 of 2131 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

3487 of 4504 relevant lines covered (77.42%)

6.09 hits per line

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

77.39

/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, Dict, List, Match, Optional, Tuple, Union

import requests

from .__init__ import __project_name__, __version__

try:
    from packaging.version import parse as parse_version
except ImportError:
    from ._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[Union[float, Tuple[float, 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.
    """
    try:
        r = requests.get(f'https://pypi.org/pypi/{__project_name__}/json', timeout=timeout)
    except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout) as e:
        logger.info(f'Exception when querying PyPi for latest release: {e}')
        return False

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

mborsetti / webchanges / 6004818396

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