11227167656

Committed 08 Oct 2024 01:57AM UTC coverage: 77.628% (-0.04%) from 77.666%

Build # 11227167656

Build Type

push

github

Committed by

mborsetti

Commit Message

Version 3.26.0rc0

Run Details

1750 of 2524 branches covered (69.33%)

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.

4475 of 5495 relevant lines covered (81.44%)

4.75 hits per line

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

78.62

/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 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, Iterable, Match

from markdown2 import Markdown

from webchanges import __project_name__, __version__

try:
    import httpx
except ImportError:  # pragma: no cover
    httpx = None  # type: ignore[assignment]
if httpx is not None:
    try:
        import h2
    except ImportError:  # pragma: no cover
        h2 = None  # type: ignore[assignment]

try:
    from packaging.version import parse as parse_version
except ImportError:  # pragma: no cover
    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

    @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: str | bytes | PathLike) -> None:
    """Opens the editor to edit a file.

    :param filename: The filename.
    """
    editor = os.environ.get('EDITOR')
    if not editor:
        editor = os.environ.get('VISUAL')
    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: 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: 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(  # original re
    #     r'\b('
    #     r'(?:([\w-]+):(/{1,3})|www[.])'
    #     r'(?:('
    #     r'?:(?:[^\s&()]|&amp;|&quot;)*(?:[^!"#$%&'
    #     r"'()*+,.:;<=>?@\[\]^`{|}~\s])"
    #     r")"
    #     r'|(?:\((?:[^\s&()]|&amp;|&quot;)*\))'
    #     r')+'
    #     r')'
    # )  # noqa: DUO138 catastrophic "re" usage - denial-of-service possible.

    _URL_RE = re.compile(  # modified to catch all URL parameters
        r'\b('
        r'(?:([\w-]+):(/{1,3})|www[.])'
        r'(?:('
        r'?:(?:[^\s()])*(?:[^!"#$%&'
        r"'()*+,.:;<=>?@\[\]^`{|}~\s])"
        r')'
        r'|(?:\((?:[^\s()])*\))'
        r')+'
        r')'
    )  # 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:
            proto = 'https'
            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: float | None = None) -> 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 False

    try:
        r = httpx.Client(http2=h2 is not None, timeout=timeout).get(f'https://pypi.org/pypi/{__project_name__}/json')
    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 or root 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 not in {current_uid, 0}:
        file_ownership_errors.append(f'{dirname} not owned by {getpass.getuser()} or root')

    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 not in {current_uid, 0}:
        file_ownership_errors.append(f'{filename} not owned by {getpass.getuser()} or root')

    return file_ownership_errors


def mark_to_html(text: str, markdown_padded_tables: bool | None = False, extras: Iterable[str] | None = None) -> str:
    """Converts a line of Markdown (e.g. as generated by html2text filter) to html.

    :param text: The text in Markdown format.
    :param markdown_padded_tables: If true, monospace the tables for alignment.
    :param extras: Additional extras for Markdown.
    :return: The text in html format.
    """
    markdowner_extras = set(extras) if extras else set()
    markdowner_extras.add('strike')  # text marked by double tildes is ~~strikethrough~~
    markdowner_extras.add('target-blank-links')  # <a> tags have rel="noopener" for added security
    markdowner = Markdown(extras=list(markdowner_extras))
    if text == '* * *':  # manually expand horizontal ruler since <hr> is used to separate jobs
        return '-' * 80
    pre = ''
    post = ''
    if text.lstrip()[:2] == '* ':  # item of unordered list
        lstripped = text.lstrip(' ')
        indent = len(text) - len(lstripped)
        pre += '&nbsp;' * indent
        pre += '● ' if indent == 2 else '⯀ ' if indent == 4 else '○ '
        text = text.split('* ', 1)[1]
    if text[:1] == ' ':
        # replace leading spaces with NBSP or converter will strip them all
        stripped = text.lstrip()
        text = '&nbsp;' * (len(text) - len(stripped)) + stripped
    text = text.replace('` ', '`&nbsp;')  # replace leading spaces within code blocks
    if markdown_padded_tables and '|' in text:
        # a padded row in a table; keep it monospaced for alignment
        pre += '<span style="font-family:monospace;white-space:pre-wrap">'
        post += '</span>'
    text = text.replace('[](', '[[_Link with no text_]](')  # Add link text where missing
    html_out = str(markdowner.convert(text)).rstrip('\n')  # convert markdown to html
    # fixes for Gmail
    html_out = html_out.replace('<a', '<a style="font-family:inherit"')  # fix <a> tag styling
    html_out = html_out.replace('<img', '<img style="max-width:100%;height:auto;max-height:100%"')
    html_out = html_out.replace('<code>', '<span style="font-family:monospace;white-space:pre-wrap">')
    html_out = html_out.replace('</code>', '</span>')
    if 'tables' in markdowner_extras:
        html_out = html_out.replace('<table>', '<table border="1" cellspacing="0">')
    # remove <p> tags wrapping
    html_out, sub = re.subn(r'^<p>|</p>$', '', html_out)  # remove paragraph tags
    if sub:
        return pre + html_out + post
    html_out = re.sub(r'<(/?)h\d>', r'<\g<1>strong>', html_out)  # replace heading tags with <strong>
    return pre + html_out + post

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

mborsetti / webchanges / 11227167656

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