Add files using upload-large-folder tool

evalkit_tf446/lib/python3.10/site-packages/google_resumable_media-2.7.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

evalkit_tf446/lib/python3.10/site-packages/google_resumable_media-2.7.2.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: google-resumable-media
+Version: 2.7.2
+Summary: Utilities for Google Media Downloads and Resumable Uploads
+Home-page: https://github.com/googleapis/google-resumable-media-python
+Author: Google Cloud Platform
+Author-email: googleapis-publisher@google.com
+License: Apache 2.0
+Platform: Posix; MacOS X; Windows
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Requires-Python: >= 3.7
+License-File: LICENSE
+Requires-Dist: google-crc32c <2.0dev,>=1.0
+Provides-Extra: aiohttp
+Requires-Dist: aiohttp <4.0.0dev,>=3.6.2 ; extra == 'aiohttp'
+Requires-Dist: google-auth <2.0dev,>=1.22.0 ; extra == 'aiohttp'
+Provides-Extra: requests
+Requires-Dist: requests <3.0.0dev,>=2.18.0 ; extra == 'requests'
+
+``google-resumable-media``
+==========================
+
+
+Utilities for Google Media Downloads and Resumable Uploads
+
+
+See the `docs`_ for examples and usage.
+
+.. _docs: https://googleapis.dev/python/google-resumable-media/latest/index.html
+
+Experimental `asyncio` Support
+------------------------------
+While still in development and subject to change, this library has `asyncio`
+support at `google._async_resumable_media`. 
+
+Supported Python Versions
+-------------------------
+Python >= 3.7
+
+Unsupported Python Versions
+---------------------------
+
+Python == 2.7, Python == 3.5, Python == 3.6.
+
+The last version of this library compatible with Python 2.7 and 3.5 is
+`google-resumable-media==1.3.3`.
+
+The last version of this library compatible with Python 3.6 is
+`google-resumable-media==2.3.3`.
+
+License
+-------
+
+Apache 2.0 - See `the LICENSE`_ for more information.
+
+.. _the LICENSE: https://github.com/googleapis/google-resumable-media-python/blob/main/LICENSE

evalkit_tf446/lib/python3.10/site-packages/google_resumable_media-2.7.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.2.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

evalkit_tf446/lib/python3.10/site-packages/google_resumable_media-2.7.2.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+google
+testing

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/case.py

@@ -0,0 +1,157 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: April 19, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Simple case insensitive dictionaries.
+
+The :class:`CaseInsensitiveDict` class is a dictionary whose string keys
+are case insensitive. It works by automatically coercing string keys to
+:class:`CaseInsensitiveKey` objects. Keys that are not strings are
+supported as well, just without case insensitivity.
+
+At its core this module works by normalizing strings to lowercase before
+comparing or hashing them. It doesn't support proper case folding nor
+does it support Unicode normalization, hence the word "simple".
+"""
+
+# Standard library modules.
+import collections
+
+try:
+    # Python >= 3.3.
+    from collections.abc import Iterable, Mapping
+except ImportError:
+    # Python 2.7.
+    from collections import Iterable, Mapping
+
+# Modules included in our package.
+from humanfriendly.compat import basestring, unicode
+
+# Public identifiers that require documentation.
+__all__ = ("CaseInsensitiveDict", "CaseInsensitiveKey")
+
+
+class CaseInsensitiveDict(collections.OrderedDict):
+
+    """
+    Simple case insensitive dictionary implementation (that remembers insertion order).
+
+    This class works by overriding methods that deal with dictionary keys to
+    coerce string keys to :class:`CaseInsensitiveKey` objects before calling
+    down to the regular dictionary handling methods. While intended to be
+    complete this class has not been extensively tested yet.
+    """
+
+    def __init__(self, other=None, **kw):
+        """Initialize a :class:`CaseInsensitiveDict` object."""
+        # Initialize our superclass.
+        super(CaseInsensitiveDict, self).__init__()
+        # Handle the initializer arguments.
+        self.update(other, **kw)
+
+    def coerce_key(self, key):
+        """
+        Coerce string keys to :class:`CaseInsensitiveKey` objects.
+
+        :param key: The value to coerce (any type).
+        :returns: If `key` is a string then a :class:`CaseInsensitiveKey`
+                  object is returned, otherwise the value of `key` is
+                  returned unmodified.
+        """
+        if isinstance(key, basestring):
+            key = CaseInsensitiveKey(key)
+        return key
+
+    @classmethod
+    def fromkeys(cls, iterable, value=None):
+        """Create a case insensitive dictionary with keys from `iterable` and values set to `value`."""
+        return cls((k, value) for k in iterable)
+
+    def get(self, key, default=None):
+        """Get the value of an existing item."""
+        return super(CaseInsensitiveDict, self).get(self.coerce_key(key), default)
+
+    def pop(self, key, default=None):
+        """Remove an item from a case insensitive dictionary."""
+        return super(CaseInsensitiveDict, self).pop(self.coerce_key(key), default)
+
+    def setdefault(self, key, default=None):
+        """Get the value of an existing item or add a new item."""
+        return super(CaseInsensitiveDict, self).setdefault(self.coerce_key(key), default)
+
+    def update(self, other=None, **kw):
+        """Update a case insensitive dictionary with new items."""
+        if isinstance(other, Mapping):
+            # Copy the items from the given mapping.
+            for key, value in other.items():
+                self[key] = value
+        elif isinstance(other, Iterable):
+            # Copy the items from the given iterable.
+            for key, value in other:
+                self[key] = value
+        elif other is not None:
+            # Complain about unsupported values.
+            msg = "'%s' object is not iterable"
+            type_name = type(value).__name__
+            raise TypeError(msg % type_name)
+        # Copy the keyword arguments (if any).
+        for key, value in kw.items():
+            self[key] = value
+
+    def __contains__(self, key):
+        """Check if a case insensitive dictionary contains the given key."""
+        return super(CaseInsensitiveDict, self).__contains__(self.coerce_key(key))
+
+    def __delitem__(self, key):
+        """Delete an item in a case insensitive dictionary."""
+        return super(CaseInsensitiveDict, self).__delitem__(self.coerce_key(key))
+
+    def __getitem__(self, key):
+        """Get the value of an item in a case insensitive dictionary."""
+        return super(CaseInsensitiveDict, self).__getitem__(self.coerce_key(key))
+
+    def __setitem__(self, key, value):
+        """Set the value of an item in a case insensitive dictionary."""
+        return super(CaseInsensitiveDict, self).__setitem__(self.coerce_key(key), value)
+
+
+class CaseInsensitiveKey(unicode):
+
+    """
+    Simple case insensitive dictionary key implementation.
+
+    The :class:`CaseInsensitiveKey` class provides an intentionally simple
+    implementation of case insensitive strings to be used as dictionary keys.
+
+    If you need features like Unicode normalization or proper case folding
+    please consider using a more advanced implementation like the :pypi:`istr`
+    package instead.
+    """
+
+    def __new__(cls, value):
+        """Create a :class:`CaseInsensitiveKey` object."""
+        # Delegate string object creation to our superclass.
+        obj = unicode.__new__(cls, value)
+        # Store the lowercased string and its hash value.
+        normalized = obj.lower()
+        obj._normalized = normalized
+        obj._hash_value = hash(normalized)
+        return obj
+
+    def __hash__(self):
+        """Get the hash value of the lowercased string."""
+        return self._hash_value
+
+    def __eq__(self, other):
+        """Compare two strings as lowercase."""
+        if isinstance(other, CaseInsensitiveKey):
+            # Fast path (and the most common case): Comparison with same type.
+            return self._normalized == other._normalized
+        elif isinstance(other, unicode):
+            # Slow path: Comparison with strings that need lowercasing.
+            return self._normalized == other.lower()
+        else:
+            return NotImplemented

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/cli.py

@@ -0,0 +1,291 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: March 1, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Usage: humanfriendly [OPTIONS]
+
+Human friendly input/output (text formatting) on the command
+line based on the Python package with the same name.
+
+Supported options:
+
+  -c, --run-command
+
+    Execute an external command (given as the positional arguments) and render
+    a spinner and timer while the command is running. The exit status of the
+    command is propagated.
+
+  --format-table
+
+    Read tabular data from standard input (each line is a row and each
+    whitespace separated field is a column), format the data as a table and
+    print the resulting table to standard output. See also the --delimiter
+    option.
+
+  -d, --delimiter=VALUE
+
+    Change the delimiter used by --format-table to VALUE (a string). By default
+    all whitespace is treated as a delimiter.
+
+  -l, --format-length=LENGTH
+
+    Convert a length count (given as the integer or float LENGTH) into a human
+    readable string and print that string to standard output.
+
+  -n, --format-number=VALUE
+
+    Format a number (given as the integer or floating point number VALUE) with
+    thousands separators and two decimal places (if needed) and print the
+    formatted number to standard output.
+
+  -s, --format-size=BYTES
+
+    Convert a byte count (given as the integer BYTES) into a human readable
+    string and print that string to standard output.
+
+  -b, --binary
+
+    Change the output of -s, --format-size to use binary multiples of bytes
+    (base-2) instead of the default decimal multiples of bytes (base-10).
+
+  -t, --format-timespan=SECONDS
+
+    Convert a number of seconds (given as the floating point number SECONDS)
+    into a human readable timespan and print that string to standard output.
+
+  --parse-length=VALUE
+
+    Parse a human readable length (given as the string VALUE) and print the
+    number of metres to standard output.
+
+  --parse-size=VALUE
+
+    Parse a human readable data size (given as the string VALUE) and print the
+    number of bytes to standard output.
+
+  --demo
+
+    Demonstrate changing the style and color of the terminal font using ANSI
+    escape sequences.
+
+  -h, --help
+
+    Show this message and exit.
+"""
+
+# Standard library modules.
+import functools
+import getopt
+import pipes
+import subprocess
+import sys
+
+# Modules included in our package.
+from humanfriendly import (
+    Timer,
+    format_length,
+    format_number,
+    format_size,
+    format_timespan,
+    parse_length,
+    parse_size,
+)
+from humanfriendly.tables import format_pretty_table, format_smart_table
+from humanfriendly.terminal import (
+    ANSI_COLOR_CODES,
+    ANSI_TEXT_STYLES,
+    HIGHLIGHT_COLOR,
+    ansi_strip,
+    ansi_wrap,
+    enable_ansi_support,
+    find_terminal_size,
+    output,
+    usage,
+    warning,
+)
+from humanfriendly.terminal.spinners import Spinner
+
+# Public identifiers that require documentation.
+__all__ = (
+    'demonstrate_256_colors',
+    'demonstrate_ansi_formatting',
+    'main',
+    'print_formatted_length',
+    'print_formatted_number',
+    'print_formatted_size',
+    'print_formatted_table',
+    'print_formatted_timespan',
+    'print_parsed_length',
+    'print_parsed_size',
+    'run_command',
+)
+
+
+def main():
+    """Command line interface for the ``humanfriendly`` program."""
+    enable_ansi_support()
+    try:
+        options, arguments = getopt.getopt(sys.argv[1:], 'cd:l:n:s:bt:h', [
+            'run-command', 'format-table', 'delimiter=', 'format-length=',
+            'format-number=', 'format-size=', 'binary', 'format-timespan=',
+            'parse-length=', 'parse-size=', 'demo', 'help',
+        ])
+    except Exception as e:
+        warning("Error: %s", e)
+        sys.exit(1)
+    actions = []
+    delimiter = None
+    should_format_table = False
+    binary = any(o in ('-b', '--binary') for o, v in options)
+    for option, value in options:
+        if option in ('-d', '--delimiter'):
+            delimiter = value
+        elif option == '--parse-size':
+            actions.append(functools.partial(print_parsed_size, value))
+        elif option == '--parse-length':
+            actions.append(functools.partial(print_parsed_length, value))
+        elif option in ('-c', '--run-command'):
+            actions.append(functools.partial(run_command, arguments))
+        elif option in ('-l', '--format-length'):
+            actions.append(functools.partial(print_formatted_length, value))
+        elif option in ('-n', '--format-number'):
+            actions.append(functools.partial(print_formatted_number, value))
+        elif option in ('-s', '--format-size'):
+            actions.append(functools.partial(print_formatted_size, value, binary))
+        elif option == '--format-table':
+            should_format_table = True
+        elif option in ('-t', '--format-timespan'):
+            actions.append(functools.partial(print_formatted_timespan, value))
+        elif option == '--demo':
+            actions.append(demonstrate_ansi_formatting)
+        elif option in ('-h', '--help'):
+            usage(__doc__)
+            return
+    if should_format_table:
+        actions.append(functools.partial(print_formatted_table, delimiter))
+    if not actions:
+        usage(__doc__)
+        return
+    for partial in actions:
+        partial()
+
+
+def run_command(command_line):
+    """Run an external command and show a spinner while the command is running."""
+    timer = Timer()
+    spinner_label = "Waiting for command: %s" % " ".join(map(pipes.quote, command_line))
+    with Spinner(label=spinner_label, timer=timer) as spinner:
+        process = subprocess.Popen(command_line)
+        while True:
+            spinner.step()
+            spinner.sleep()
+            if process.poll() is not None:
+                break
+    sys.exit(process.returncode)
+
+
+def print_formatted_length(value):
+    """Print a human readable length."""
+    if '.' in value:
+        output(format_length(float(value)))
+    else:
+        output(format_length(int(value)))
+
+
+def print_formatted_number(value):
+    """Print large numbers in a human readable format."""
+    output(format_number(float(value)))
+
+
+def print_formatted_size(value, binary):
+    """Print a human readable size."""
+    output(format_size(int(value), binary=binary))
+
+
+def print_formatted_table(delimiter):
+    """Read tabular data from standard input and print a table."""
+    data = []
+    for line in sys.stdin:
+        line = line.rstrip()
+        data.append(line.split(delimiter))
+    output(format_pretty_table(data))
+
+
+def print_formatted_timespan(value):
+    """Print a human readable timespan."""
+    output(format_timespan(float(value)))
+
+
+def print_parsed_length(value):
+    """Parse a human readable length and print the number of metres."""
+    output(parse_length(value))
+
+
+def print_parsed_size(value):
+    """Parse a human readable data size and print the number of bytes."""
+    output(parse_size(value))
+
+
+def demonstrate_ansi_formatting():
+    """Demonstrate the use of ANSI escape sequences."""
+    # First we demonstrate the supported text styles.
+    output('%s', ansi_wrap('Text styles:', bold=True))
+    styles = ['normal', 'bright']
+    styles.extend(ANSI_TEXT_STYLES.keys())
+    for style_name in sorted(styles):
+        options = dict(color=HIGHLIGHT_COLOR)
+        if style_name != 'normal':
+            options[style_name] = True
+        style_label = style_name.replace('_', ' ').capitalize()
+        output(' - %s', ansi_wrap(style_label, **options))
+    # Now we demonstrate named foreground and background colors.
+    for color_type, color_label in (('color', 'Foreground colors'),
+                                    ('background', 'Background colors')):
+        intensities = [
+            ('normal', dict()),
+            ('bright', dict(bright=True)),
+        ]
+        if color_type != 'background':
+            intensities.insert(0, ('faint', dict(faint=True)))
+        output('\n%s' % ansi_wrap('%s:' % color_label, bold=True))
+        output(format_smart_table([
+            [color_name] + [
+                ansi_wrap(
+                    'XXXXXX' if color_type != 'background' else (' ' * 6),
+                    **dict(list(kw.items()) + [(color_type, color_name)])
+                ) for label, kw in intensities
+            ] for color_name in sorted(ANSI_COLOR_CODES.keys())
+        ], column_names=['Color'] + [
+            label.capitalize() for label, kw in intensities
+        ]))
+    # Demonstrate support for 256 colors as well.
+    demonstrate_256_colors(0, 7, 'standard colors')
+    demonstrate_256_colors(8, 15, 'high-intensity colors')
+    demonstrate_256_colors(16, 231, '216 colors')
+    demonstrate_256_colors(232, 255, 'gray scale colors')
+
+
+def demonstrate_256_colors(i, j, group=None):
+    """Demonstrate 256 color mode support."""
+    # Generate the label.
+    label = '256 color mode'
+    if group:
+        label += ' (%s)' % group
+    output('\n' + ansi_wrap('%s:' % label, bold=True))
+    # Generate a simple rendering of the colors in the requested range and
+    # check if it will fit on a single line (given the terminal's width).
+    single_line = ''.join(' ' + ansi_wrap(str(n), color=n) for n in range(i, j + 1))
+    lines, columns = find_terminal_size()
+    if columns >= len(ansi_strip(single_line)):
+        output(single_line)
+    else:
+        # Generate a more complex rendering of the colors that will nicely wrap
+        # over multiple lines without using too many lines.
+        width = len(str(j)) + 1
+        colors_per_line = int(columns / width)
+        colors = [ansi_wrap(str(n).rjust(width), color=n) for n in range(i, j + 1)]
+        blocks = [colors[n:n + colors_per_line] for n in range(0, len(colors), colors_per_line)]
+        output('\n'.join(''.join(b) for b in blocks))

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/compat.py

@@ -0,0 +1,146 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: September 17, 2021
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Compatibility with Python 2 and 3.
+
+This module exposes aliases and functions that make it easier to write Python
+code that is compatible with Python 2 and Python 3.
+
+.. data:: basestring
+
+   Alias for :func:`python2:basestring` (in Python 2) or :class:`python3:str`
+   (in Python 3). See also :func:`is_string()`.
+
+.. data:: HTMLParser
+
+   Alias for :class:`python2:HTMLParser.HTMLParser` (in Python 2) or
+   :class:`python3:html.parser.HTMLParser` (in Python 3).
+
+.. data:: interactive_prompt
+
+   Alias for :func:`python2:raw_input()` (in Python 2) or
+   :func:`python3:input()` (in Python 3).
+
+.. data:: StringIO
+
+   Alias for :class:`python2:StringIO.StringIO` (in Python 2) or
+   :class:`python3:io.StringIO` (in Python 3).
+
+.. data:: unicode
+
+   Alias for :func:`python2:unicode` (in Python 2) or :class:`python3:str` (in
+   Python 3). See also :func:`coerce_string()`.
+
+.. data:: monotonic
+
+   Alias for :func:`python3:time.monotonic()` (in Python 3.3 and higher) or
+   `monotonic.monotonic()` (a `conditional dependency
+   <https://pypi.org/project/monotonic/>`_ on older Python versions).
+"""
+
+__all__ = (
+    'HTMLParser',
+    'StringIO',
+    'basestring',
+    'coerce_string',
+    'interactive_prompt',
+    'is_string',
+    'is_unicode',
+    'monotonic',
+    'name2codepoint',
+    'on_macos',
+    'on_windows',
+    'unichr',
+    'unicode',
+    'which',
+)
+
+# Standard library modules.
+import sys
+
+# Differences between Python 2 and 3.
+try:
+    # Python 2.
+    unicode = unicode
+    unichr = unichr
+    basestring = basestring
+    interactive_prompt = raw_input
+    from distutils.spawn import find_executable as which
+    from HTMLParser import HTMLParser
+    from StringIO import StringIO
+    from htmlentitydefs import name2codepoint
+except (ImportError, NameError):
+    # Python 3.
+    unicode = str
+    unichr = chr
+    basestring = str
+    interactive_prompt = input
+    from shutil import which
+    from html.parser import HTMLParser
+    from io import StringIO
+    from html.entities import name2codepoint
+
+try:
+    # Python 3.3 and higher.
+    from time import monotonic
+except ImportError:
+    # A replacement for older Python versions:
+    # https://pypi.org/project/monotonic/
+    try:
+        from monotonic import monotonic
+    except (ImportError, RuntimeError):
+        # We fall back to the old behavior of using time.time() instead of
+        # failing when {time,monotonic}.monotonic() are both missing.
+        from time import time as monotonic
+
+
+def coerce_string(value):
+    """
+    Coerce any value to a Unicode string (:func:`python2:unicode` in Python 2 and :class:`python3:str` in Python 3).
+
+    :param value: The value to coerce.
+    :returns: The value coerced to a Unicode string.
+    """
+    return value if is_string(value) else unicode(value)
+
+
+def is_string(value):
+    """
+    Check if a value is a :func:`python2:basestring` (in Python 2) or :class:`python3:str` (in Python 3) object.
+
+    :param value: The value to check.
+    :returns: :data:`True` if the value is a string, :data:`False` otherwise.
+    """
+    return isinstance(value, basestring)
+
+
+def is_unicode(value):
+    """
+    Check if a value is a :func:`python2:unicode` (in Python 2) or :class:`python2:str` (in Python 3) object.
+
+    :param value: The value to check.
+    :returns: :data:`True` if the value is a Unicode string, :data:`False` otherwise.
+    """
+    return isinstance(value, unicode)
+
+
+def on_macos():
+    """
+    Check if we're running on Apple MacOS.
+
+    :returns: :data:`True` if running MacOS, :data:`False` otherwise.
+    """
+    return sys.platform.startswith('darwin')
+
+
+def on_windows():
+    """
+    Check if we're running on the Microsoft Windows OS.
+
+    :returns: :data:`True` if running Windows, :data:`False` otherwise.
+    """
+    return sys.platform.startswith('win')

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/deprecation.py

@@ -0,0 +1,251 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: March 2, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Support for deprecation warnings when importing names from old locations.
+
+When software evolves, things tend to move around. This is usually detrimental
+to backwards compatibility (in Python this primarily manifests itself as
+:exc:`~exceptions.ImportError` exceptions).
+
+While backwards compatibility is very important, it should not get in the way
+of progress. It would be great to have the agility to move things around
+without breaking backwards compatibility.
+
+This is where the :mod:`humanfriendly.deprecation` module comes in: It enables
+the definition of backwards compatible aliases that emit a deprecation warning
+when they are accessed.
+
+The way it works is that it wraps the original module in an :class:`DeprecationProxy`
+object that defines a :func:`~DeprecationProxy.__getattr__()` special method to
+override attribute access of the module.
+"""
+
+# Standard library modules.
+import collections
+import functools
+import importlib
+import inspect
+import sys
+import types
+import warnings
+
+# Modules included in our package.
+from humanfriendly.text import format
+
+# Registry of known aliases (used by humanfriendly.sphinx).
+REGISTRY = collections.defaultdict(dict)
+
+# Public identifiers that require documentation.
+__all__ = ("DeprecationProxy", "define_aliases", "deprecated_args", "get_aliases", "is_method")
+
+
+def define_aliases(module_name, **aliases):
+    """
+    Update a module with backwards compatible aliases.
+
+    :param module_name: The ``__name__`` of the module (a string).
+    :param aliases: Each keyword argument defines an alias. The values
+                    are expected to be "dotted paths" (strings).
+
+    The behavior of this function depends on whether the Sphinx documentation
+    generator is active, because the use of :class:`DeprecationProxy` to shadow the
+    real module in :data:`sys.modules` has the unintended side effect of
+    breaking autodoc support for ``:data:`` members (module variables).
+
+    To avoid breaking Sphinx the proxy object is omitted and instead the
+    aliased names are injected into the original module namespace, to make sure
+    that imports can be satisfied when the documentation is being rendered.
+
+    If you run into cyclic dependencies caused by :func:`define_aliases()` when
+    running Sphinx, you can try moving the call to :func:`define_aliases()` to
+    the bottom of the Python module you're working on.
+    """
+    module = sys.modules[module_name]
+    proxy = DeprecationProxy(module, aliases)
+    # Populate the registry of aliases.
+    for name, target in aliases.items():
+        REGISTRY[module.__name__][name] = target
+    # Avoid confusing Sphinx.
+    if "sphinx" in sys.modules:
+        for name, target in aliases.items():
+            setattr(module, name, proxy.resolve(target))
+    else:
+        # Install a proxy object to raise DeprecationWarning.
+        sys.modules[module_name] = proxy
+
+
+def get_aliases(module_name):
+    """
+    Get the aliases defined by a module.
+
+    :param module_name: The ``__name__`` of the module (a string).
+    :returns: A dictionary with string keys and values:
+
+              1. Each key gives the name of an alias
+                 created for backwards compatibility.
+
+              2. Each value gives the dotted path of
+                 the proper location of the identifier.
+
+              An empty dictionary is returned for modules that
+              don't define any backwards compatible aliases.
+    """
+    return REGISTRY.get(module_name, {})
+
+
+def deprecated_args(*names):
+    """
+    Deprecate positional arguments without dropping backwards compatibility.
+
+    :param names:
+
+      The positional arguments to :func:`deprecated_args()` give the names of
+      the positional arguments that the to-be-decorated function should warn
+      about being deprecated and translate to keyword arguments.
+
+    :returns: A decorator function specialized to `names`.
+
+    The :func:`deprecated_args()` decorator function was created to make it
+    easy to switch from positional arguments to keyword arguments [#]_ while
+    preserving backwards compatibility [#]_ and informing call sites
+    about the change.
+
+    .. [#] Increased flexibility is the main reason why I find myself switching
+           from positional arguments to (optional) keyword arguments as my code
+           evolves to support more use cases.
+
+    .. [#] In my experience positional argument order implicitly becomes part
+           of API compatibility whether intended or not. While this makes sense
+           for functions that over time adopt more and more optional arguments,
+           at a certain point it becomes an inconvenience to code maintenance.
+
+    Here's an example of how to use the decorator::
+
+      @deprecated_args('text')
+      def report_choice(**options):
+          print(options['text'])
+
+    When the decorated function is called with positional arguments
+    a deprecation warning is given::
+
+      >>> report_choice('this will give a deprecation warning')
+      DeprecationWarning: report_choice has deprecated positional arguments, please switch to keyword arguments
+      this will give a deprecation warning
+
+    But when the function is called with keyword arguments no deprecation
+    warning is emitted::
+
+      >>> report_choice(text='this will not give a deprecation warning')
+      this will not give a deprecation warning
+    """
+    def decorator(function):
+        def translate(args, kw):
+            # Raise TypeError when too many positional arguments are passed to the decorated function.
+            if len(args) > len(names):
+                raise TypeError(
+                    format(
+                        "{name} expected at most {limit} arguments, got {count}",
+                        name=function.__name__,
+                        limit=len(names),
+                        count=len(args),
+                    )
+                )
+            # Emit a deprecation warning when positional arguments are used.
+            if args:
+                warnings.warn(
+                    format(
+                        "{name} has deprecated positional arguments, please switch to keyword arguments",
+                        name=function.__name__,
+                    ),
+                    category=DeprecationWarning,
+                    stacklevel=3,
+                )
+            # Translate positional arguments to keyword arguments.
+            for name, value in zip(names, args):
+                kw[name] = value
+        if is_method(function):
+            @functools.wraps(function)
+            def wrapper(*args, **kw):
+                """Wrapper for instance methods."""
+                args = list(args)
+                self = args.pop(0)
+                translate(args, kw)
+                return function(self, **kw)
+        else:
+            @functools.wraps(function)
+            def wrapper(*args, **kw):
+                """Wrapper for module level functions."""
+                translate(args, kw)
+                return function(**kw)
+        return wrapper
+    return decorator
+
+
+def is_method(function):
+    """Check if the expected usage of the given function is as an instance method."""
+    try:
+        # Python 3.3 and newer.
+        signature = inspect.signature(function)
+        return "self" in signature.parameters
+    except AttributeError:
+        # Python 3.2 and older.
+        metadata = inspect.getargspec(function)
+        return "self" in metadata.args
+
+
+class DeprecationProxy(types.ModuleType):
+
+    """Emit deprecation warnings for imports that should be updated."""
+
+    def __init__(self, module, aliases):
+        """
+        Initialize an :class:`DeprecationProxy` object.
+
+        :param module: The original module object.
+        :param aliases: A dictionary of aliases.
+        """
+        # Initialize our superclass.
+        super(DeprecationProxy, self).__init__(name=module.__name__)
+        # Store initializer arguments.
+        self.module = module
+        self.aliases = aliases
+
+    def __getattr__(self, name):
+        """
+        Override module attribute lookup.
+
+        :param name: The name to look up (a string).
+        :returns: The attribute value.
+        """
+        # Check if the given name is an alias.
+        target = self.aliases.get(name)
+        if target is not None:
+            # Emit the deprecation warning.
+            warnings.warn(
+                format("%s.%s was moved to %s, please update your imports", self.module.__name__, name, target),
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            # Resolve the dotted path.
+            return self.resolve(target)
+        # Look up the name in the original module namespace.
+        value = getattr(self.module, name, None)
+        if value is not None:
+            return value
+        # Fall back to the default behavior.
+        raise AttributeError(format("module '%s' has no attribute '%s'", self.module.__name__, name))
+
+    def resolve(self, target):
+        """
+        Look up the target of an alias.
+
+        :param target: The fully qualified dotted path (a string).
+        :returns: The value of the given target.
+        """
+        module_name, _, member = target.rpartition(".")
+        module = importlib.import_module(module_name)
+        return getattr(module, member)

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/sphinx.py

@@ -0,0 +1,315 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: June 11, 2021
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Customizations for and integration with the Sphinx_ documentation generator.
+
+The :mod:`humanfriendly.sphinx` module uses the `Sphinx extension API`_ to
+customize the process of generating Sphinx based Python documentation. To
+explore the functionality this module offers its best to start reading
+from the :func:`setup()` function.
+
+.. _Sphinx: http://www.sphinx-doc.org/
+.. _Sphinx extension API: http://sphinx-doc.org/extdev/appapi.html
+"""
+
+# Standard library modules.
+import logging
+import types
+
+# External dependencies (if Sphinx is installed docutils will be installed).
+import docutils.nodes
+import docutils.utils
+
+# Modules included in our package.
+from humanfriendly.deprecation import get_aliases
+from humanfriendly.text import compact, dedent, format
+from humanfriendly.usage import USAGE_MARKER, render_usage
+
+# Public identifiers that require documentation.
+__all__ = (
+    "deprecation_note_callback",
+    "enable_deprecation_notes",
+    "enable_man_role",
+    "enable_pypi_role",
+    "enable_special_methods",
+    "enable_usage_formatting",
+    "logger",
+    "man_role",
+    "pypi_role",
+    "setup",
+    "special_methods_callback",
+    "usage_message_callback",
+)
+
+# Initialize a logger for this module.
+logger = logging.getLogger(__name__)
+
+
+def deprecation_note_callback(app, what, name, obj, options, lines):
+    """
+    Automatically document aliases defined using :func:`~humanfriendly.deprecation.define_aliases()`.
+
+    Refer to :func:`enable_deprecation_notes()` to enable the use of this
+    function (you probably don't want to call :func:`deprecation_note_callback()`
+    directly).
+
+    This function implements a callback for ``autodoc-process-docstring`` that
+    reformats module docstrings to append an overview of aliases defined by the
+    module.
+
+    The parameters expected by this function are those defined for Sphinx event
+    callback functions (i.e. I'm not going to document them here :-).
+    """
+    if isinstance(obj, types.ModuleType) and lines:
+        aliases = get_aliases(obj.__name__)
+        if aliases:
+            # Convert the existing docstring to a string and remove leading
+            # indentation from that string, otherwise our generated content
+            # would have to match the existing indentation in order not to
+            # break docstring parsing (because indentation is significant
+            # in the reStructuredText format).
+            blocks = [dedent("\n".join(lines))]
+            # Use an admonition to group the deprecated aliases together and
+            # to distinguish them from the autodoc entries that follow.
+            blocks.append(".. note:: Deprecated names")
+            indent = " " * 3
+            if len(aliases) == 1:
+                explanation = """
+                    The following alias exists to preserve backwards compatibility,
+                    however a :exc:`~exceptions.DeprecationWarning` is triggered
+                    when it is accessed, because this alias will be removed
+                    in a future release.
+                """
+            else:
+                explanation = """
+                    The following aliases exist to preserve backwards compatibility,
+                    however a :exc:`~exceptions.DeprecationWarning` is triggered
+                    when they are accessed, because these aliases will be
+                    removed in a future release.
+                """
+            blocks.append(indent + compact(explanation))
+            for name, target in aliases.items():
+                blocks.append(format("%s.. data:: %s", indent, name))
+                blocks.append(format("%sAlias for :obj:`%s`.", indent * 2, target))
+            update_lines(lines, "\n\n".join(blocks))
+
+
+def enable_deprecation_notes(app):
+    """
+    Enable documenting backwards compatibility aliases using the autodoc_ extension.
+
+    :param app: The Sphinx application object.
+
+    This function connects the :func:`deprecation_note_callback()` function to
+    ``autodoc-process-docstring`` events.
+
+    .. _autodoc: http://www.sphinx-doc.org/en/stable/ext/autodoc.html
+    """
+    app.connect("autodoc-process-docstring", deprecation_note_callback)
+
+
+def enable_man_role(app):
+    """
+    Enable the ``:man:`` role for linking to Debian Linux manual pages.
+
+    :param app: The Sphinx application object.
+
+    This function registers the :func:`man_role()` function to handle the
+    ``:man:`` role.
+    """
+    app.add_role("man", man_role)
+
+
+def enable_pypi_role(app):
+    """
+    Enable the ``:pypi:`` role for linking to the Python Package Index.
+
+    :param app: The Sphinx application object.
+
+    This function registers the :func:`pypi_role()` function to handle the
+    ``:pypi:`` role.
+    """
+    app.add_role("pypi", pypi_role)
+
+
+def enable_special_methods(app):
+    """
+    Enable documenting "special methods" using the autodoc_ extension.
+
+    :param app: The Sphinx application object.
+
+    This function connects the :func:`special_methods_callback()` function to
+    ``autodoc-skip-member`` events.
+
+    .. _autodoc: http://www.sphinx-doc.org/en/stable/ext/autodoc.html
+    """
+    app.connect("autodoc-skip-member", special_methods_callback)
+
+
+def enable_usage_formatting(app):
+    """
+    Reformat human friendly usage messages to reStructuredText_.
+
+    :param app: The Sphinx application object (as given to ``setup()``).
+
+    This function connects the :func:`usage_message_callback()` function to
+    ``autodoc-process-docstring`` events.
+
+    .. _reStructuredText: https://en.wikipedia.org/wiki/ReStructuredText
+    """
+    app.connect("autodoc-process-docstring", usage_message_callback)
+
+
+def man_role(role, rawtext, text, lineno, inliner, options={}, content=[]):
+    """
+    Convert a Linux manual topic to a hyperlink.
+
+    Using the ``:man:`` role is very simple, here's an example:
+
+    .. code-block:: rst
+
+        See the :man:`python` documentation.
+
+    This results in the following:
+
+      See the :man:`python` documentation.
+
+    As the example shows you can use the role inline, embedded in sentences of
+    text. In the generated documentation the ``:man:`` text is omitted and a
+    hyperlink pointing to the Debian Linux manual pages is emitted.
+    """
+    man_url = "https://manpages.debian.org/%s" % text
+    reference = docutils.nodes.reference(rawtext, docutils.utils.unescape(text), refuri=man_url, **options)
+    return [reference], []
+
+
+def pypi_role(role, rawtext, text, lineno, inliner, options={}, content=[]):
+    """
+    Generate hyperlinks to the Python Package Index.
+
+    Using the ``:pypi:`` role is very simple, here's an example:
+
+    .. code-block:: rst
+
+        See the :pypi:`humanfriendly` package.
+
+    This results in the following:
+
+      See the :pypi:`humanfriendly` package.
+
+    As the example shows you can use the role inline, embedded in sentences of
+    text. In the generated documentation the ``:pypi:`` text is omitted and a
+    hyperlink pointing to the Python Package Index is emitted.
+    """
+    pypi_url = "https://pypi.org/project/%s/" % text
+    reference = docutils.nodes.reference(rawtext, docutils.utils.unescape(text), refuri=pypi_url, **options)
+    return [reference], []
+
+
+def setup(app):
+    """
+    Enable all of the provided Sphinx_ customizations.
+
+    :param app: The Sphinx application object.
+
+    The :func:`setup()` function makes it easy to enable all of the Sphinx
+    customizations provided by the :mod:`humanfriendly.sphinx` module with the
+    least amount of code. All you need to do is to add the module name to the
+    ``extensions`` variable in your ``conf.py`` file:
+
+    .. code-block:: python
+
+       # Sphinx extension module names.
+       extensions = [
+           'sphinx.ext.autodoc',
+           'sphinx.ext.doctest',
+           'sphinx.ext.intersphinx',
+           'humanfriendly.sphinx',
+       ]
+
+    When Sphinx sees the :mod:`humanfriendly.sphinx` name it will import the
+    module and call its :func:`setup()` function. This function will then call
+    the following:
+
+    - :func:`enable_deprecation_notes()`
+    - :func:`enable_man_role()`
+    - :func:`enable_pypi_role()`
+    - :func:`enable_special_methods()`
+    - :func:`enable_usage_formatting()`
+
+    Of course more functionality may be added at a later stage. If you don't
+    like that idea you may be better of calling the individual functions from
+    your own ``setup()`` function.
+    """
+    from humanfriendly import __version__
+
+    enable_deprecation_notes(app)
+    enable_man_role(app)
+    enable_pypi_role(app)
+    enable_special_methods(app)
+    enable_usage_formatting(app)
+
+    return dict(parallel_read_safe=True, parallel_write_safe=True, version=__version__)
+
+
+def special_methods_callback(app, what, name, obj, skip, options):
+    """
+    Enable documenting "special methods" using the autodoc_ extension.
+
+    Refer to :func:`enable_special_methods()` to enable the use of this
+    function (you probably don't want to call
+    :func:`special_methods_callback()` directly).
+
+    This function implements a callback for ``autodoc-skip-member`` events to
+    include documented "special methods" (method names with two leading and two
+    trailing underscores) in your documentation. The result is similar to the
+    use of the ``special-members`` flag with one big difference: Special
+    methods are included but other types of members are ignored. This means
+    that attributes like ``__weakref__`` will always be ignored (this was my
+    main annoyance with the ``special-members`` flag).
+
+    The parameters expected by this function are those defined for Sphinx event
+    callback functions (i.e. I'm not going to document them here :-).
+    """
+    if getattr(obj, "__doc__", None) and isinstance(obj, (types.FunctionType, types.MethodType)):
+        return False
+    else:
+        return skip
+
+
+def update_lines(lines, text):
+    """Private helper for ``autodoc-process-docstring`` callbacks."""
+    while lines:
+        lines.pop()
+    lines.extend(text.splitlines())
+
+
+def usage_message_callback(app, what, name, obj, options, lines):
+    """
+    Reformat human friendly usage messages to reStructuredText_.
+
+    Refer to :func:`enable_usage_formatting()` to enable the use of this
+    function (you probably don't want to call :func:`usage_message_callback()`
+    directly).
+
+    This function implements a callback for ``autodoc-process-docstring`` that
+    reformats module docstrings using :func:`.render_usage()` so that Sphinx
+    doesn't mangle usage messages that were written to be human readable
+    instead of machine readable. Only module docstrings whose first line starts
+    with :data:`.USAGE_MARKER` are reformatted.
+
+    The parameters expected by this function are those defined for Sphinx event
+    callback functions (i.e. I'm not going to document them here :-).
+    """
+    # Make sure we only modify the docstrings of modules.
+    if isinstance(obj, types.ModuleType) and lines:
+        # Make sure we only modify docstrings containing a usage message.
+        if lines[0].startswith(USAGE_MARKER):
+            # Convert the usage message to reStructuredText.
+            text = render_usage("\n".join(lines))
+            # Fill up the buffer with our modified docstring.
+            update_lines(lines, text)

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/tables.py

@@ -0,0 +1,341 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: February 16, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Functions that render ASCII tables.
+
+Some generic notes about the table formatting functions in this module:
+
+- These functions were not written with performance in mind (*at all*) because
+  they're intended to format tabular data to be presented on a terminal. If
+  someone were to run into a performance problem using these functions, they'd
+  be printing so much tabular data to the terminal that a human wouldn't be
+  able to digest the tabular data anyway, so the point is moot :-).
+
+- These functions ignore ANSI escape sequences (at least the ones generated by
+  the :mod:`~humanfriendly.terminal` module) in the calculation of columns
+  widths. On reason for this is that column names are highlighted in color when
+  connected to a terminal. It also means that you can use ANSI escape sequences
+  to highlight certain column's values if you feel like it (for example to
+  highlight deviations from the norm in an overview of calculated values).
+"""
+
+# Standard library modules.
+import collections
+import re
+
+# Modules included in our package.
+from humanfriendly.compat import coerce_string
+from humanfriendly.terminal import (
+    ansi_strip,
+    ansi_width,
+    ansi_wrap,
+    terminal_supports_colors,
+    find_terminal_size,
+    HIGHLIGHT_COLOR,
+)
+
+# Public identifiers that require documentation.
+__all__ = (
+    'format_pretty_table',
+    'format_robust_table',
+    'format_rst_table',
+    'format_smart_table',
+)
+
+# Compiled regular expression pattern to recognize table columns containing
+# numeric data (integer and/or floating point numbers). Used to right-align the
+# contents of such columns.
+#
+# Pre-emptive snarky comment: This pattern doesn't match every possible
+# floating point number notation!?!1!1
+#
+# Response: I know, that's intentional. The use of this regular expression
+# pattern has a very high DWIM level and weird floating point notations do not
+# fall under the DWIM umbrella :-).
+NUMERIC_DATA_PATTERN = re.compile(r'^\d+(\.\d+)?$')
+
+
+def format_smart_table(data, column_names):
+    """
+    Render tabular data using the most appropriate representation.
+
+    :param data: An iterable (e.g. a :func:`tuple` or :class:`list`)
+                 containing the rows of the table, where each row is an
+                 iterable containing the columns of the table (strings).
+    :param column_names: An iterable of column names (strings).
+    :returns: The rendered table (a string).
+
+    If you want an easy way to render tabular data on a terminal in a human
+    friendly format then this function is for you! It works as follows:
+
+    - If the input data doesn't contain any line breaks the function
+      :func:`format_pretty_table()` is used to render a pretty table. If the
+      resulting table fits in the terminal without wrapping the rendered pretty
+      table is returned.
+
+    - If the input data does contain line breaks or if a pretty table would
+      wrap (given the width of the terminal) then the function
+      :func:`format_robust_table()` is used to render a more robust table that
+      can deal with data containing line breaks and long text.
+    """
+    # Normalize the input in case we fall back from a pretty table to a robust
+    # table (in which case we'll definitely iterate the input more than once).
+    data = [normalize_columns(r) for r in data]
+    column_names = normalize_columns(column_names)
+    # Make sure the input data doesn't contain any line breaks (because pretty
+    # tables break horribly when a column's text contains a line break :-).
+    if not any(any('\n' in c for c in r) for r in data):
+        # Render a pretty table.
+        pretty_table = format_pretty_table(data, column_names)
+        # Check if the pretty table fits in the terminal.
+        table_width = max(map(ansi_width, pretty_table.splitlines()))
+        num_rows, num_columns = find_terminal_size()
+        if table_width <= num_columns:
+            # The pretty table fits in the terminal without wrapping!
+            return pretty_table
+    # Fall back to a robust table when a pretty table won't work.
+    return format_robust_table(data, column_names)
+
+
+def format_pretty_table(data, column_names=None, horizontal_bar='-', vertical_bar='|'):
+    """
+    Render a table using characters like dashes and vertical bars to emulate borders.
+
+    :param data: An iterable (e.g. a :func:`tuple` or :class:`list`)
+                 containing the rows of the table, where each row is an
+                 iterable containing the columns of the table (strings).
+    :param column_names: An iterable of column names (strings).
+    :param horizontal_bar: The character used to represent a horizontal bar (a
+                           string).
+    :param vertical_bar: The character used to represent a vertical bar (a
+                         string).
+    :returns: The rendered table (a string).
+
+    Here's an example:
+
+    >>> from humanfriendly.tables import format_pretty_table
+    >>> column_names = ['Version', 'Uploaded on', 'Downloads']
+    >>> humanfriendly_releases = [
+    ... ['1.23', '2015-05-25', '218'],
+    ... ['1.23.1', '2015-05-26', '1354'],
+    ... ['1.24', '2015-05-26', '223'],
+    ... ['1.25', '2015-05-26', '4319'],
+    ... ['1.25.1', '2015-06-02', '197'],
+    ... ]
+    >>> print(format_pretty_table(humanfriendly_releases, column_names))
+    -------------------------------------
+    | Version | Uploaded on | Downloads |
+    -------------------------------------
+    | 1.23    | 2015-05-25  |       218 |
+    | 1.23.1  | 2015-05-26  |      1354 |
+    | 1.24    | 2015-05-26  |       223 |
+    | 1.25    | 2015-05-26  |      4319 |
+    | 1.25.1  | 2015-06-02  |       197 |
+    -------------------------------------
+
+    Notes about the resulting table:
+
+    - If a column contains numeric data (integer and/or floating point
+      numbers) in all rows (ignoring column names of course) then the content
+      of that column is right-aligned, as can be seen in the example above. The
+      idea here is to make it easier to compare the numbers in different
+      columns to each other.
+
+    - The column names are highlighted in color so they stand out a bit more
+      (see also :data:`.HIGHLIGHT_COLOR`). The following screen shot shows what
+      that looks like (my terminals are always set to white text on a black
+      background):
+
+      .. image:: images/pretty-table.png
+    """
+    # Normalize the input because we'll have to iterate it more than once.
+    data = [normalize_columns(r, expandtabs=True) for r in data]
+    if column_names is not None:
+        column_names = normalize_columns(column_names)
+        if column_names:
+            if terminal_supports_colors():
+                column_names = [highlight_column_name(n) for n in column_names]
+            data.insert(0, column_names)
+    # Calculate the maximum width of each column.
+    widths = collections.defaultdict(int)
+    numeric_data = collections.defaultdict(list)
+    for row_index, row in enumerate(data):
+        for column_index, column in enumerate(row):
+            widths[column_index] = max(widths[column_index], ansi_width(column))
+            if not (column_names and row_index == 0):
+                numeric_data[column_index].append(bool(NUMERIC_DATA_PATTERN.match(ansi_strip(column))))
+    # Create a horizontal bar of dashes as a delimiter.
+    line_delimiter = horizontal_bar * (sum(widths.values()) + len(widths) * 3 + 1)
+    # Start the table with a vertical bar.
+    lines = [line_delimiter]
+    # Format the rows and columns.
+    for row_index, row in enumerate(data):
+        line = [vertical_bar]
+        for column_index, column in enumerate(row):
+            padding = ' ' * (widths[column_index] - ansi_width(column))
+            if all(numeric_data[column_index]):
+                line.append(' ' + padding + column + ' ')
+            else:
+                line.append(' ' + column + padding + ' ')
+            line.append(vertical_bar)
+        lines.append(u''.join(line))
+        if column_names and row_index == 0:
+            lines.append(line_delimiter)
+    # End the table with a vertical bar.
+    lines.append(line_delimiter)
+    # Join the lines, returning a single string.
+    return u'\n'.join(lines)
+
+
+def format_robust_table(data, column_names):
+    """
+    Render tabular data with one column per line (allowing columns with line breaks).
+
+    :param data: An iterable (e.g. a :func:`tuple` or :class:`list`)
+                 containing the rows of the table, where each row is an
+                 iterable containing the columns of the table (strings).
+    :param column_names: An iterable of column names (strings).
+    :returns: The rendered table (a string).
+
+    Here's an example:
+
+    >>> from humanfriendly.tables import format_robust_table
+    >>> column_names = ['Version', 'Uploaded on', 'Downloads']
+    >>> humanfriendly_releases = [
+    ... ['1.23', '2015-05-25', '218'],
+    ... ['1.23.1', '2015-05-26', '1354'],
+    ... ['1.24', '2015-05-26', '223'],
+    ... ['1.25', '2015-05-26', '4319'],
+    ... ['1.25.1', '2015-06-02', '197'],
+    ... ]
+    >>> print(format_robust_table(humanfriendly_releases, column_names))
+    -----------------------
+    Version: 1.23
+    Uploaded on: 2015-05-25
+    Downloads: 218
+    -----------------------
+    Version: 1.23.1
+    Uploaded on: 2015-05-26
+    Downloads: 1354
+    -----------------------
+    Version: 1.24
+    Uploaded on: 2015-05-26
+    Downloads: 223
+    -----------------------
+    Version: 1.25
+    Uploaded on: 2015-05-26
+    Downloads: 4319
+    -----------------------
+    Version: 1.25.1
+    Uploaded on: 2015-06-02
+    Downloads: 197
+    -----------------------
+
+    The column names are highlighted in bold font and color so they stand out a
+    bit more (see :data:`.HIGHLIGHT_COLOR`).
+    """
+    blocks = []
+    column_names = ["%s:" % n for n in normalize_columns(column_names)]
+    if terminal_supports_colors():
+        column_names = [highlight_column_name(n) for n in column_names]
+    # Convert each row into one or more `name: value' lines (one per column)
+    # and group each `row of lines' into a block (i.e. rows become blocks).
+    for row in data:
+        lines = []
+        for column_index, column_text in enumerate(normalize_columns(row)):
+            stripped_column = column_text.strip()
+            if '\n' not in stripped_column:
+                # Columns without line breaks are formatted inline.
+                lines.append("%s %s" % (column_names[column_index], stripped_column))
+            else:
+                # Columns with line breaks could very well contain indented
+                # lines, so we'll put the column name on a separate line. This
+                # way any indentation remains intact, and it's easier to
+                # copy/paste the text.
+                lines.append(column_names[column_index])
+                lines.extend(column_text.rstrip().splitlines())
+        blocks.append(lines)
+    # Calculate the width of the row delimiter.
+    num_rows, num_columns = find_terminal_size()
+    longest_line = max(max(map(ansi_width, lines)) for lines in blocks)
+    delimiter = u"\n%s\n" % ('-' * min(longest_line, num_columns))
+    # Force a delimiter at the start and end of the table.
+    blocks.insert(0, "")
+    blocks.append("")
+    # Embed the row delimiter between every two blocks.
+    return delimiter.join(u"\n".join(b) for b in blocks).strip()
+
+
+def format_rst_table(data, column_names=None):
+    """
+    Render a table in reStructuredText_ format.
+
+    :param data: An iterable (e.g. a :func:`tuple` or :class:`list`)
+                 containing the rows of the table, where each row is an
+                 iterable containing the columns of the table (strings).
+    :param column_names: An iterable of column names (strings).
+    :returns: The rendered table (a string).
+
+    Here's an example:
+
+    >>> from humanfriendly.tables import format_rst_table
+    >>> column_names = ['Version', 'Uploaded on', 'Downloads']
+    >>> humanfriendly_releases = [
+    ... ['1.23', '2015-05-25', '218'],
+    ... ['1.23.1', '2015-05-26', '1354'],
+    ... ['1.24', '2015-05-26', '223'],
+    ... ['1.25', '2015-05-26', '4319'],
+    ... ['1.25.1', '2015-06-02', '197'],
+    ... ]
+    >>> print(format_rst_table(humanfriendly_releases, column_names))
+    =======  ===========  =========
+    Version  Uploaded on  Downloads
+    =======  ===========  =========
+    1.23     2015-05-25   218
+    1.23.1   2015-05-26   1354
+    1.24     2015-05-26   223
+    1.25     2015-05-26   4319
+    1.25.1   2015-06-02   197
+    =======  ===========  =========
+
+    .. _reStructuredText: https://en.wikipedia.org/wiki/ReStructuredText
+    """
+    data = [normalize_columns(r) for r in data]
+    if column_names:
+        data.insert(0, normalize_columns(column_names))
+    # Calculate the maximum width of each column.
+    widths = collections.defaultdict(int)
+    for row in data:
+        for index, column in enumerate(row):
+            widths[index] = max(widths[index], len(column))
+    # Pad the columns using whitespace.
+    for row in data:
+        for index, column in enumerate(row):
+            if index < (len(row) - 1):
+                row[index] = column.ljust(widths[index])
+    # Add table markers.
+    delimiter = ['=' * w for i, w in sorted(widths.items())]
+    if column_names:
+        data.insert(1, delimiter)
+    data.insert(0, delimiter)
+    data.append(delimiter)
+    # Join the lines and columns together.
+    return '\n'.join('  '.join(r) for r in data)
+
+
+def normalize_columns(row, expandtabs=False):
+    results = []
+    for value in row:
+        text = coerce_string(value)
+        if expandtabs:
+            text = text.expandtabs()
+        results.append(text)
+    return results
+
+
+def highlight_column_name(name):
+    return ansi_wrap(name, bold=True, color=HIGHLIGHT_COLOR)

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/terminal/__init__.py

@@ -0,0 +1,776 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: March 1, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Interaction with interactive text terminals.
+
+The :mod:`~humanfriendly.terminal` module makes it easy to interact with
+interactive text terminals and format text for rendering on such terminals. If
+the terms used in the documentation of this module don't make sense to you then
+please refer to the `Wikipedia article on ANSI escape sequences`_ for details
+about how ANSI escape sequences work.
+
+This module was originally developed for use on UNIX systems, but since then
+Windows 10 gained native support for ANSI escape sequences and this module was
+enhanced to recognize and support this. For details please refer to the
+:func:`enable_ansi_support()` function.
+
+.. _Wikipedia article on ANSI escape sequences: http://en.wikipedia.org/wiki/ANSI_escape_code#Sequence_elements
+"""
+
+# Standard library modules.
+import codecs
+import numbers
+import os
+import platform
+import re
+import subprocess
+import sys
+
+# The `fcntl' module is platform specific so importing it may give an error. We
+# hide this implementation detail from callers by handling the import error and
+# setting a flag instead.
+try:
+    import fcntl
+    import termios
+    import struct
+    HAVE_IOCTL = True
+except ImportError:
+    HAVE_IOCTL = False
+
+# Modules included in our package.
+from humanfriendly.compat import coerce_string, is_unicode, on_windows, which
+from humanfriendly.decorators import cached
+from humanfriendly.deprecation import define_aliases
+from humanfriendly.text import concatenate, format
+from humanfriendly.usage import format_usage
+
+# Public identifiers that require documentation.
+__all__ = (
+    'ANSI_COLOR_CODES',
+    'ANSI_CSI',
+    'ANSI_ERASE_LINE',
+    'ANSI_HIDE_CURSOR',
+    'ANSI_RESET',
+    'ANSI_SGR',
+    'ANSI_SHOW_CURSOR',
+    'ANSI_TEXT_STYLES',
+    'CLEAN_OUTPUT_PATTERN',
+    'DEFAULT_COLUMNS',
+    'DEFAULT_ENCODING',
+    'DEFAULT_LINES',
+    'HIGHLIGHT_COLOR',
+    'ansi_strip',
+    'ansi_style',
+    'ansi_width',
+    'ansi_wrap',
+    'auto_encode',
+    'clean_terminal_output',
+    'connected_to_terminal',
+    'enable_ansi_support',
+    'find_terminal_size',
+    'find_terminal_size_using_ioctl',
+    'find_terminal_size_using_stty',
+    'get_pager_command',
+    'have_windows_native_ansi_support',
+    'message',
+    'output',
+    'readline_strip',
+    'readline_wrap',
+    'show_pager',
+    'terminal_supports_colors',
+    'usage',
+    'warning',
+)
+
+ANSI_CSI = '\x1b['
+"""The ANSI "Control Sequence Introducer" (a string)."""
+
+ANSI_SGR = 'm'
+"""The ANSI "Select Graphic Rendition" sequence (a string)."""
+
+ANSI_ERASE_LINE = '%sK' % ANSI_CSI
+"""The ANSI escape sequence to erase the current line (a string)."""
+
+ANSI_RESET = '%s0%s' % (ANSI_CSI, ANSI_SGR)
+"""The ANSI escape sequence to reset styling (a string)."""
+
+ANSI_HIDE_CURSOR = '%s?25l' % ANSI_CSI
+"""The ANSI escape sequence to hide the text cursor (a string)."""
+
+ANSI_SHOW_CURSOR = '%s?25h' % ANSI_CSI
+"""The ANSI escape sequence to show the text cursor (a string)."""
+
+ANSI_COLOR_CODES = dict(black=0, red=1, green=2, yellow=3, blue=4, magenta=5, cyan=6, white=7)
+"""
+A dictionary with (name, number) pairs of `portable color codes`_. Used by
+:func:`ansi_style()` to generate ANSI escape sequences that change font color.
+
+.. _portable color codes: http://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+"""
+
+ANSI_TEXT_STYLES = dict(bold=1, faint=2, italic=3, underline=4, inverse=7, strike_through=9)
+"""
+A dictionary with (name, number) pairs of text styles (effects). Used by
+:func:`ansi_style()` to generate ANSI escape sequences that change text
+styles. Only widely supported text styles are included here.
+"""
+
+CLEAN_OUTPUT_PATTERN = re.compile(u'(\r|\n|\b|%s)' % re.escape(ANSI_ERASE_LINE))
+"""
+A compiled regular expression used to separate significant characters from other text.
+
+This pattern is used by :func:`clean_terminal_output()` to split terminal
+output into regular text versus backspace, carriage return and line feed
+characters and ANSI 'erase line' escape sequences.
+"""
+
+DEFAULT_LINES = 25
+"""The default number of lines in a terminal (an integer)."""
+
+DEFAULT_COLUMNS = 80
+"""The default number of columns in a terminal (an integer)."""
+
+DEFAULT_ENCODING = 'UTF-8'
+"""The output encoding for Unicode strings."""
+
+HIGHLIGHT_COLOR = os.environ.get('HUMANFRIENDLY_HIGHLIGHT_COLOR', 'green')
+"""
+The color used to highlight important tokens in formatted text (e.g. the usage
+message of the ``humanfriendly`` program). If the environment variable
+``$HUMANFRIENDLY_HIGHLIGHT_COLOR`` is set it determines the value of
+:data:`HIGHLIGHT_COLOR`.
+"""
+
+
+def ansi_strip(text, readline_hints=True):
+    """
+    Strip ANSI escape sequences from the given string.
+
+    :param text: The text from which ANSI escape sequences should be removed (a
+                 string).
+    :param readline_hints: If :data:`True` then :func:`readline_strip()` is
+                           used to remove `readline hints`_ from the string.
+    :returns: The text without ANSI escape sequences (a string).
+    """
+    pattern = '%s.*?%s' % (re.escape(ANSI_CSI), re.escape(ANSI_SGR))
+    text = re.sub(pattern, '', text)
+    if readline_hints:
+        text = readline_strip(text)
+    return text
+
+
+def ansi_style(**kw):
+    """
+    Generate ANSI escape sequences for the given color and/or style(s).
+
+    :param color: The foreground color. Three types of values are supported:
+
+                  - The name of a color (one of the strings 'black', 'red',
+                    'green', 'yellow', 'blue', 'magenta', 'cyan' or 'white').
+                  - An integer that refers to the 256 color mode palette.
+                  - A tuple or list with three integers representing an RGB
+                    (red, green, blue) value.
+
+                  The value :data:`None` (the default) means no escape
+                  sequence to switch color will be emitted.
+    :param background: The background color (see the description
+                       of the `color` argument).
+    :param bright: Use high intensity colors instead of default colors
+                   (a boolean, defaults to :data:`False`).
+    :param readline_hints: If :data:`True` then :func:`readline_wrap()` is
+                           applied to the generated ANSI escape sequences (the
+                           default is :data:`False`).
+    :param kw: Any additional keyword arguments are expected to match a key
+               in the :data:`ANSI_TEXT_STYLES` dictionary. If the argument's
+               value evaluates to :data:`True` the respective style will be
+               enabled.
+    :returns: The ANSI escape sequences to enable the requested text styles or
+              an empty string if no styles were requested.
+    :raises: :exc:`~exceptions.ValueError` when an invalid color name is given.
+
+    Even though only eight named colors are supported, the use of `bright=True`
+    and `faint=True` increases the number of available colors to around 24 (it
+    may be slightly lower, for example because faint black is just black).
+
+    **Support for 8-bit colors**
+
+    In `release 4.7`_ support for 256 color mode was added. While this
+    significantly increases the available colors it's not very human friendly
+    in usage because you need to look up color codes in the `256 color mode
+    palette <https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit>`_.
+
+    You can use the ``humanfriendly --demo`` command to get a demonstration of
+    the available colors, see also the screen shot below. Note that the small
+    font size in the screen shot was so that the demonstration of 256 color
+    mode support would fit into a single screen shot without scrolling :-)
+    (I wasn't feeling very creative).
+
+      .. image:: images/ansi-demo.png
+
+    **Support for 24-bit colors**
+
+    In `release 4.14`_ support for 24-bit colors was added by accepting a tuple
+    or list with three integers representing the RGB (red, green, blue) value
+    of a color. This is not included in the demo because rendering millions of
+    colors was deemed unpractical ;-).
+
+    .. _release 4.7: http://humanfriendly.readthedocs.io/en/latest/changelog.html#release-4-7-2018-01-14
+    .. _release 4.14: http://humanfriendly.readthedocs.io/en/latest/changelog.html#release-4-14-2018-07-13
+    """
+    # Start with sequences that change text styles.
+    sequences = [ANSI_TEXT_STYLES[k] for k, v in kw.items() if k in ANSI_TEXT_STYLES and v]
+    # Append the color code (if any).
+    for color_type in 'color', 'background':
+        color_value = kw.get(color_type)
+        if isinstance(color_value, (tuple, list)):
+            if len(color_value) != 3:
+                msg = "Invalid color value %r! (expected tuple or list with three numbers)"
+                raise ValueError(msg % color_value)
+            sequences.append(48 if color_type == 'background' else 38)
+            sequences.append(2)
+            sequences.extend(map(int, color_value))
+        elif isinstance(color_value, numbers.Number):
+            # Numeric values are assumed to be 256 color codes.
+            sequences.extend((
+                39 if color_type == 'background' else 38,
+                5, int(color_value)
+            ))
+        elif color_value:
+            # Other values are assumed to be strings containing one of the known color names.
+            if color_value not in ANSI_COLOR_CODES:
+                msg = "Invalid color value %r! (expected an integer or one of the strings %s)"
+                raise ValueError(msg % (color_value, concatenate(map(repr, sorted(ANSI_COLOR_CODES)))))
+            # Pick the right offset for foreground versus background
+            # colors and regular intensity versus bright colors.
+            offset = (
+                (100 if kw.get('bright') else 40)
+                if color_type == 'background'
+                else (90 if kw.get('bright') else 30)
+            )
+            # Combine the offset and color code into a single integer.
+            sequences.append(offset + ANSI_COLOR_CODES[color_value])
+    if sequences:
+        encoded = ANSI_CSI + ';'.join(map(str, sequences)) + ANSI_SGR
+        return readline_wrap(encoded) if kw.get('readline_hints') else encoded
+    else:
+        return ''
+
+
+def ansi_width(text):
+    """
+    Calculate the effective width of the given text (ignoring ANSI escape sequences).
+
+    :param text: The text whose width should be calculated (a string).
+    :returns: The width of the text without ANSI escape sequences (an
+              integer).
+
+    This function uses :func:`ansi_strip()` to strip ANSI escape sequences from
+    the given string and returns the length of the resulting string.
+    """
+    return len(ansi_strip(text))
+
+
+def ansi_wrap(text, **kw):
+    """
+    Wrap text in ANSI escape sequences for the given color and/or style(s).
+
+    :param text: The text to wrap (a string).
+    :param kw: Any keyword arguments are passed to :func:`ansi_style()`.
+    :returns: The result of this function depends on the keyword arguments:
+
+              - If :func:`ansi_style()` generates an ANSI escape sequence based
+                on the keyword arguments, the given text is prefixed with the
+                generated ANSI escape sequence and suffixed with
+                :data:`ANSI_RESET`.
+
+              - If :func:`ansi_style()` returns an empty string then the text
+                given by the caller is returned unchanged.
+    """
+    start_sequence = ansi_style(**kw)
+    if start_sequence:
+        end_sequence = ANSI_RESET
+        if kw.get('readline_hints'):
+            end_sequence = readline_wrap(end_sequence)
+        return start_sequence + text + end_sequence
+    else:
+        return text
+
+
+def auto_encode(stream, text, *args, **kw):
+    """
+    Reliably write Unicode strings to the terminal.
+
+    :param stream: The file-like object to write to (a value like
+                   :data:`sys.stdout` or :data:`sys.stderr`).
+    :param text: The text to write to the stream (a string).
+    :param args: Refer to :func:`~humanfriendly.text.format()`.
+    :param kw: Refer to :func:`~humanfriendly.text.format()`.
+
+    Renders the text using :func:`~humanfriendly.text.format()` and writes it
+    to the given stream. If an :exc:`~exceptions.UnicodeEncodeError` is
+    encountered in doing so, the text is encoded using :data:`DEFAULT_ENCODING`
+    and the write is retried. The reasoning behind this rather blunt approach
+    is that it's preferable to get output on the command line in the wrong
+    encoding then to have the Python program blow up with a
+    :exc:`~exceptions.UnicodeEncodeError` exception.
+    """
+    text = format(text, *args, **kw)
+    try:
+        stream.write(text)
+    except UnicodeEncodeError:
+        stream.write(codecs.encode(text, DEFAULT_ENCODING))
+
+
+def clean_terminal_output(text):
+    """
+    Clean up the terminal output of a command.
+
+    :param text: The raw text with special characters (a Unicode string).
+    :returns: A list of Unicode strings (one for each line).
+
+    This function emulates the effect of backspace (0x08), carriage return
+    (0x0D) and line feed (0x0A) characters and the ANSI 'erase line' escape
+    sequence on interactive terminals. It's intended to clean up command output
+    that was originally meant to be rendered on an interactive terminal and
+    that has been captured using e.g. the :man:`script` program [#]_ or the
+    :mod:`pty` module [#]_.
+
+    .. [#] My coloredlogs_ package supports the ``coloredlogs --to-html``
+           command which uses :man:`script` to fool a subprocess into thinking
+           that it's connected to an interactive terminal (in order to get it
+           to emit ANSI escape sequences).
+
+    .. [#] My capturer_ package uses the :mod:`pty` module to fool the current
+           process and subprocesses into thinking they are connected to an
+           interactive terminal (in order to get them to emit ANSI escape
+           sequences).
+
+    **Some caveats about the use of this function:**
+
+    - Strictly speaking the effect of carriage returns cannot be emulated
+      outside of an actual terminal due to the interaction between overlapping
+      output, terminal widths and line wrapping. The goal of this function is
+      to sanitize noise in terminal output while preserving useful output.
+      Think of it as a useful and pragmatic but possibly lossy conversion.
+
+    - The algorithm isn't smart enough to properly handle a pair of ANSI escape
+      sequences that open before a carriage return and close after the last
+      carriage return in a linefeed delimited string; the resulting string will
+      contain only the closing end of the ANSI escape sequence pair. Tracking
+      this kind of complexity requires a state machine and proper parsing.
+
+    .. _capturer: https://pypi.org/project/capturer
+    .. _coloredlogs: https://pypi.org/project/coloredlogs
+    """
+    cleaned_lines = []
+    current_line = ''
+    current_position = 0
+    for token in CLEAN_OUTPUT_PATTERN.split(text):
+        if token == '\r':
+            # Seek back to the start of the current line.
+            current_position = 0
+        elif token == '\b':
+            # Seek back one character in the current line.
+            current_position = max(0, current_position - 1)
+        else:
+            if token == '\n':
+                # Capture the current line.
+                cleaned_lines.append(current_line)
+            if token in ('\n', ANSI_ERASE_LINE):
+                # Clear the current line.
+                current_line = ''
+                current_position = 0
+            elif token:
+                # Merge regular output into the current line.
+                new_position = current_position + len(token)
+                prefix = current_line[:current_position]
+                suffix = current_line[new_position:]
+                current_line = prefix + token + suffix
+                current_position = new_position
+    # Capture the last line (if any).
+    cleaned_lines.append(current_line)
+    # Remove any empty trailing lines.
+    while cleaned_lines and not cleaned_lines[-1]:
+        cleaned_lines.pop(-1)
+    return cleaned_lines
+
+
+def connected_to_terminal(stream=None):
+    """
+    Check if a stream is connected to a terminal.
+
+    :param stream: The stream to check (a file-like object,
+                   defaults to :data:`sys.stdout`).
+    :returns: :data:`True` if the stream is connected to a terminal,
+              :data:`False` otherwise.
+
+    See also :func:`terminal_supports_colors()`.
+    """
+    stream = sys.stdout if stream is None else stream
+    try:
+        return stream.isatty()
+    except Exception:
+        return False
+
+
+@cached
+def enable_ansi_support():
+    """
+    Try to enable support for ANSI escape sequences (required on Windows).
+
+    :returns: :data:`True` if ANSI is supported, :data:`False` otherwise.
+
+    This functions checks for the following supported configurations, in the
+    given order:
+
+    1. On Windows, if :func:`have_windows_native_ansi_support()` confirms
+       native support for ANSI escape sequences :mod:`ctypes` will be used to
+       enable this support.
+
+    2. On Windows, if the environment variable ``$ANSICON`` is set nothing is
+       done because it is assumed that support for ANSI escape sequences has
+       already been enabled via `ansicon <https://github.com/adoxa/ansicon>`_.
+
+    3. On Windows, an attempt is made to import and initialize the Python
+       package :pypi:`colorama` instead (of course for this to work
+       :pypi:`colorama` has to be installed).
+
+    4. On other platforms this function calls :func:`connected_to_terminal()`
+       to determine whether ANSI escape sequences are supported (that is to
+       say all platforms that are not Windows are assumed to support ANSI
+       escape sequences natively, without weird contortions like above).
+
+       This makes it possible to call :func:`enable_ansi_support()`
+       unconditionally without checking the current platform.
+
+    The :func:`~humanfriendly.decorators.cached` decorator is used to ensure
+    that this function is only executed once, but its return value remains
+    available on later calls.
+    """
+    if have_windows_native_ansi_support():
+        import ctypes
+        ctypes.windll.kernel32.SetConsoleMode(ctypes.windll.kernel32.GetStdHandle(-11), 7)
+        ctypes.windll.kernel32.SetConsoleMode(ctypes.windll.kernel32.GetStdHandle(-12), 7)
+        return True
+    elif on_windows():
+        if 'ANSICON' in os.environ:
+            return True
+        try:
+            import colorama
+            colorama.init()
+            return True
+        except ImportError:
+            return False
+    else:
+        return connected_to_terminal()
+
+
+def find_terminal_size():
+    """
+    Determine the number of lines and columns visible in the terminal.
+
+    :returns: A tuple of two integers with the line and column count.
+
+    The result of this function is based on the first of the following three
+    methods that works:
+
+    1. First :func:`find_terminal_size_using_ioctl()` is tried,
+    2. then :func:`find_terminal_size_using_stty()` is tried,
+    3. finally :data:`DEFAULT_LINES` and :data:`DEFAULT_COLUMNS` are returned.
+
+    .. note:: The :func:`find_terminal_size()` function performs the steps
+              above every time it is called, the result is not cached. This is
+              because the size of a virtual terminal can change at any time and
+              the result of :func:`find_terminal_size()` should be correct.
+
+              `Pre-emptive snarky comment`_: It's possible to cache the result
+              of this function and use :mod:`signal.SIGWINCH <signal>` to
+              refresh the cached values!
+
+              Response: As a library I don't consider it the role of the
+              :mod:`humanfriendly.terminal` module to install a process wide
+              signal handler ...
+
+    .. _Pre-emptive snarky comment: http://blogs.msdn.com/b/oldnewthing/archive/2008/01/30/7315957.aspx
+    """
+    # The first method. Any of the standard streams may have been redirected
+    # somewhere and there's no telling which, so we'll just try them all.
+    for stream in sys.stdin, sys.stdout, sys.stderr:
+        try:
+            result = find_terminal_size_using_ioctl(stream)
+            if min(result) >= 1:
+                return result
+        except Exception:
+            pass
+    # The second method.
+    try:
+        result = find_terminal_size_using_stty()
+        if min(result) >= 1:
+            return result
+    except Exception:
+        pass
+    # Fall back to conservative defaults.
+    return DEFAULT_LINES, DEFAULT_COLUMNS
+
+
+def find_terminal_size_using_ioctl(stream):
+    """
+    Find the terminal size using :func:`fcntl.ioctl()`.
+
+    :param stream: A stream connected to the terminal (a file object with a
+                   ``fileno`` attribute).
+    :returns: A tuple of two integers with the line and column count.
+    :raises: This function can raise exceptions but I'm not going to document
+             them here, you should be using :func:`find_terminal_size()`.
+
+    Based on an `implementation found on StackOverflow <http://stackoverflow.com/a/3010495/788200>`_.
+    """
+    if not HAVE_IOCTL:
+        raise NotImplementedError("It looks like the `fcntl' module is not available!")
+    h, w, hp, wp = struct.unpack('HHHH', fcntl.ioctl(stream, termios.TIOCGWINSZ, struct.pack('HHHH', 0, 0, 0, 0)))
+    return h, w
+
+
+def find_terminal_size_using_stty():
+    """
+    Find the terminal size using the external command ``stty size``.
+
+    :param stream: A stream connected to the terminal (a file object).
+    :returns: A tuple of two integers with the line and column count.
+    :raises: This function can raise exceptions but I'm not going to document
+             them here, you should be using :func:`find_terminal_size()`.
+    """
+    stty = subprocess.Popen(['stty', 'size'],
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE)
+    stdout, stderr = stty.communicate()
+    tokens = stdout.split()
+    if len(tokens) != 2:
+        raise Exception("Invalid output from `stty size'!")
+    return tuple(map(int, tokens))
+
+
+def get_pager_command(text=None):
+    """
+    Get the command to show a text on the terminal using a pager.
+
+    :param text: The text to print to the terminal (a string).
+    :returns: A list of strings with the pager command and arguments.
+
+    The use of a pager helps to avoid the wall of text effect where the user
+    has to scroll up to see where the output began (not very user friendly).
+
+    If the given text contains ANSI escape sequences the command ``less
+    --RAW-CONTROL-CHARS`` is used, otherwise the environment variable
+    ``$PAGER`` is used (if ``$PAGER`` isn't set :man:`less` is used).
+
+    When the selected pager is :man:`less`, the following options are used to
+    make the experience more user friendly:
+
+    - ``--quit-if-one-screen`` causes :man:`less` to automatically exit if the
+      entire text can be displayed on the first screen. This makes the use of a
+      pager transparent for smaller texts (because the operator doesn't have to
+      quit the pager).
+
+    - ``--no-init`` prevents :man:`less` from clearing the screen when it
+      exits. This ensures that the operator gets a chance to review the text
+      (for example a usage message) after quitting the pager, while composing
+      the next command.
+    """
+    # Compose the pager command.
+    if text and ANSI_CSI in text:
+        command_line = ['less', '--RAW-CONTROL-CHARS']
+    else:
+        command_line = [os.environ.get('PAGER', 'less')]
+    # Pass some additional options to `less' (to make it more
+    # user friendly) without breaking support for other pagers.
+    if os.path.basename(command_line[0]) == 'less':
+        command_line.append('--no-init')
+        command_line.append('--quit-if-one-screen')
+    return command_line
+
+
+@cached
+def have_windows_native_ansi_support():
+    """
+    Check if we're running on a Windows 10 release with native support for ANSI escape sequences.
+
+    :returns: :data:`True` if so, :data:`False` otherwise.
+
+    The :func:`~humanfriendly.decorators.cached` decorator is used as a minor
+    performance optimization. Semantically this should have zero impact because
+    the answer doesn't change in the lifetime of a computer process.
+    """
+    if on_windows():
+        try:
+            # I can't be 100% sure this will never break and I'm not in a
+            # position to test it thoroughly either, so I decided that paying
+            # the price of one additional try / except statement is worth the
+            # additional peace of mind :-).
+            components = tuple(int(c) for c in platform.version().split('.'))
+            return components >= (10, 0, 14393)
+        except Exception:
+            pass
+    return False
+
+
+def message(text, *args, **kw):
+    """
+    Print a formatted message to the standard error stream.
+
+    For details about argument handling please refer to
+    :func:`~humanfriendly.text.format()`.
+
+    Renders the message using :func:`~humanfriendly.text.format()` and writes
+    the resulting string (followed by a newline) to :data:`sys.stderr` using
+    :func:`auto_encode()`.
+    """
+    auto_encode(sys.stderr, coerce_string(text) + '\n', *args, **kw)
+
+
+def output(text, *args, **kw):
+    """
+    Print a formatted message to the standard output stream.
+
+    For details about argument handling please refer to
+    :func:`~humanfriendly.text.format()`.
+
+    Renders the message using :func:`~humanfriendly.text.format()` and writes
+    the resulting string (followed by a newline) to :data:`sys.stdout` using
+    :func:`auto_encode()`.
+    """
+    auto_encode(sys.stdout, coerce_string(text) + '\n', *args, **kw)
+
+
+def readline_strip(expr):
+    """
+    Remove `readline hints`_ from a string.
+
+    :param text: The text to strip (a string).
+    :returns: The stripped text.
+    """
+    return expr.replace('\001', '').replace('\002', '')
+
+
+def readline_wrap(expr):
+    """
+    Wrap an ANSI escape sequence in `readline hints`_.
+
+    :param text: The text with the escape sequence to wrap (a string).
+    :returns: The wrapped text.
+
+    .. _readline hints: http://superuser.com/a/301355
+    """
+    return '\001' + expr + '\002'
+
+
+def show_pager(formatted_text, encoding=DEFAULT_ENCODING):
+    """
+    Print a large text to the terminal using a pager.
+
+    :param formatted_text: The text to print to the terminal (a string).
+    :param encoding: The name of the text encoding used to encode the formatted
+                     text if the formatted text is a Unicode string (a string,
+                     defaults to :data:`DEFAULT_ENCODING`).
+
+    When :func:`connected_to_terminal()` returns :data:`True` a pager is used
+    to show the text on the terminal, otherwise the text is printed directly
+    without invoking a pager.
+
+    The use of a pager helps to avoid the wall of text effect where the user
+    has to scroll up to see where the output began (not very user friendly).
+
+    Refer to :func:`get_pager_command()` for details about the command line
+    that's used to invoke the pager.
+    """
+    if connected_to_terminal():
+        # Make sure the selected pager command is available.
+        command_line = get_pager_command(formatted_text)
+        if which(command_line[0]):
+            pager = subprocess.Popen(command_line, stdin=subprocess.PIPE)
+            if is_unicode(formatted_text):
+                formatted_text = formatted_text.encode(encoding)
+            pager.communicate(input=formatted_text)
+            return
+    output(formatted_text)
+
+
+def terminal_supports_colors(stream=None):
+    """
+    Check if a stream is connected to a terminal that supports ANSI escape sequences.
+
+    :param stream: The stream to check (a file-like object,
+                   defaults to :data:`sys.stdout`).
+    :returns: :data:`True` if the terminal supports ANSI escape sequences,
+              :data:`False` otherwise.
+
+    This function was originally inspired by the implementation of
+    `django.core.management.color.supports_color()
+    <https://github.com/django/django/blob/master/django/core/management/color.py>`_
+    but has since evolved significantly.
+    """
+    if on_windows():
+        # On Windows support for ANSI escape sequences is not a given.
+        have_ansicon = 'ANSICON' in os.environ
+        have_colorama = 'colorama' in sys.modules
+        have_native_support = have_windows_native_ansi_support()
+        if not (have_ansicon or have_colorama or have_native_support):
+            return False
+    return connected_to_terminal(stream)
+
+
+def usage(usage_text):
+    """
+    Print a human friendly usage message to the terminal.
+
+    :param text: The usage message to print (a string).
+
+    This function does two things:
+
+    1. If :data:`sys.stdout` is connected to a terminal (see
+       :func:`connected_to_terminal()`) then the usage message is formatted
+       using :func:`.format_usage()`.
+    2. The usage message is shown using a pager (see :func:`show_pager()`).
+    """
+    if terminal_supports_colors(sys.stdout):
+        usage_text = format_usage(usage_text)
+    show_pager(usage_text)
+
+
+def warning(text, *args, **kw):
+    """
+    Show a warning message on the terminal.
+
+    For details about argument handling please refer to
+    :func:`~humanfriendly.text.format()`.
+
+    Renders the message using :func:`~humanfriendly.text.format()` and writes
+    the resulting string (followed by a newline) to :data:`sys.stderr` using
+    :func:`auto_encode()`.
+
+    If :data:`sys.stderr` is connected to a terminal that supports colors,
+    :func:`ansi_wrap()` is used to color the message in a red font (to make
+    the warning stand out from surrounding text).
+    """
+    text = coerce_string(text)
+    if terminal_supports_colors(sys.stderr):
+        text = ansi_wrap(text, color='red')
+    auto_encode(sys.stderr, text + '\n', *args, **kw)
+
+
+# Define aliases for backwards compatibility.
+define_aliases(
+    module_name=__name__,
+    # In humanfriendly 1.31 the find_meta_variables() and format_usage()
+    # functions were extracted to the new module humanfriendly.usage.
+    find_meta_variables='humanfriendly.usage.find_meta_variables',
+    format_usage='humanfriendly.usage.format_usage',
+    # In humanfriendly 8.0 the html_to_ansi() function and HTMLConverter
+    # class were extracted to the new module humanfriendly.terminal.html.
+    html_to_ansi='humanfriendly.terminal.html.html_to_ansi',
+    HTMLConverter='humanfriendly.terminal.html.HTMLConverter',
+)

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/terminal/html.py

@@ -0,0 +1,423 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: February 29, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""Convert HTML with simple text formatting to text with ANSI escape sequences."""
+
+# Standard library modules.
+import re
+
+# Modules included in our package.
+from humanfriendly.compat import HTMLParser, StringIO, name2codepoint, unichr
+from humanfriendly.text import compact_empty_lines
+from humanfriendly.terminal import ANSI_COLOR_CODES, ANSI_RESET, ansi_style
+
+# Public identifiers that require documentation.
+__all__ = ('HTMLConverter', 'html_to_ansi')
+
+
+def html_to_ansi(data, callback=None):
+    """
+    Convert HTML with simple text formatting to text with ANSI escape sequences.
+
+    :param data: The HTML to convert (a string).
+    :param callback: Optional callback to pass to :class:`HTMLConverter`.
+    :returns: Text with ANSI escape sequences (a string).
+
+    Please refer to the documentation of the :class:`HTMLConverter` class for
+    details about the conversion process (like which tags are supported) and an
+    example with a screenshot.
+    """
+    converter = HTMLConverter(callback=callback)
+    return converter(data)
+
+
+class HTMLConverter(HTMLParser):
+
+    """
+    Convert HTML with simple text formatting to text with ANSI escape sequences.
+
+    The following text styles are supported:
+
+    - Bold: ``<b>``, ``<strong>`` and ``<span style="font-weight: bold;">``
+    - Italic: ``<i>``, ``<em>`` and ``<span style="font-style: italic;">``
+    - Strike-through: ``<del>``, ``<s>`` and ``<span style="text-decoration: line-through;">``
+    - Underline: ``<ins>``, ``<u>`` and ``<span style="text-decoration: underline">``
+
+    Colors can be specified as follows:
+
+    - Foreground color: ``<span style="color: #RRGGBB;">``
+    - Background color: ``<span style="background-color: #RRGGBB;">``
+
+    Here's a small demonstration:
+
+    .. code-block:: python
+
+       from humanfriendly.text import dedent
+       from humanfriendly.terminal import html_to_ansi
+
+       print(html_to_ansi(dedent('''
+         <b>Hello world!</b>
+         <i>Is this thing on?</i>
+         I guess I can <u>underline</u> or <s>strike-through</s> text?
+         And what about <span style="color: red">color</span>?
+       ''')))
+
+       rainbow_colors = [
+           '#FF0000', '#E2571E', '#FF7F00', '#FFFF00', '#00FF00',
+           '#96BF33', '#0000FF', '#4B0082', '#8B00FF', '#FFFFFF',
+       ]
+       html_rainbow = "".join('<span style="color: %s">o</span>' % c for c in rainbow_colors)
+       print(html_to_ansi("Let's try a rainbow: %s" % html_rainbow))
+
+    Here's what the results look like:
+
+      .. image:: images/html-to-ansi.png
+
+    Some more details:
+
+    - Nested tags are supported, within reasonable limits.
+
+    - Text in ``<code>`` and ``<pre>`` tags will be highlighted in a
+      different color from the main text (currently this is yellow).
+
+    - ``<a href="URL">TEXT</a>`` is converted to the format "TEXT (URL)" where
+      the uppercase symbols are highlighted in light blue with an underline.
+
+    - ``<div>``, ``<p>`` and ``<pre>`` tags are considered block level tags
+      and are wrapped in vertical whitespace to prevent their content from
+      "running into" surrounding text. This may cause runs of multiple empty
+      lines to be emitted. As a *workaround* the :func:`__call__()` method
+      will automatically call :func:`.compact_empty_lines()` on the generated
+      output before returning it to the caller. Of course this won't work
+      when `output` is set to something like :data:`sys.stdout`.
+
+    - ``<br>`` is converted to a single plain text line break.
+
+    Implementation notes:
+
+    - A list of dictionaries with style information is used as a stack where
+      new styling can be pushed and a pop will restore the previous styling.
+      When new styling is pushed, it is merged with (but overrides) the current
+      styling.
+
+    - If you're going to be converting a lot of HTML it might be useful from
+      a performance standpoint to re-use an existing :class:`HTMLConverter`
+      object for unrelated HTML fragments, in this case take a look at the
+      :func:`__call__()` method (it makes this use case very easy).
+
+    .. versionadded:: 4.15
+       :class:`humanfriendly.terminal.HTMLConverter` was added to the
+       `humanfriendly` package during the initial development of my new
+       `chat-archive <https://chat-archive.readthedocs.io/>`_ project, whose
+       command line interface makes for a great demonstration of the
+       flexibility that this feature provides (hint: check out how the search
+       keyword highlighting combines with the regular highlighting).
+    """
+
+    BLOCK_TAGS = ('div', 'p', 'pre')
+    """The names of tags that are padded with vertical whitespace."""
+
+    def __init__(self, *args, **kw):
+        """
+        Initialize an :class:`HTMLConverter` object.
+
+        :param callback: Optional keyword argument to specify a function that
+                         will be called to process text fragments before they
+                         are emitted on the output stream. Note that link text
+                         and preformatted text fragments are not processed by
+                         this callback.
+        :param output: Optional keyword argument to redirect the output to the
+                       given file-like object. If this is not given a new
+                       :class:`~python3:io.StringIO` object is created.
+        """
+        # Hide our optional keyword arguments from the superclass.
+        self.callback = kw.pop("callback", None)
+        self.output = kw.pop("output", None)
+        # Initialize the superclass.
+        HTMLParser.__init__(self, *args, **kw)
+
+    def __call__(self, data):
+        """
+        Reset the parser, convert some HTML and get the text with ANSI escape sequences.
+
+        :param data: The HTML to convert to text (a string).
+        :returns: The converted text (only in case `output` is
+                  a :class:`~python3:io.StringIO` object).
+        """
+        self.reset()
+        self.feed(data)
+        self.close()
+        if isinstance(self.output, StringIO):
+            return compact_empty_lines(self.output.getvalue())
+
+    @property
+    def current_style(self):
+        """Get the current style from the top of the stack (a dictionary)."""
+        return self.stack[-1] if self.stack else {}
+
+    def close(self):
+        """
+        Close previously opened ANSI escape sequences.
+
+        This method overrides the same method in the superclass to ensure that
+        an :data:`.ANSI_RESET` code is emitted when parsing reaches the end of
+        the input but a style is still active. This is intended to prevent
+        malformed HTML from messing up terminal output.
+        """
+        if any(self.stack):
+            self.output.write(ANSI_RESET)
+            self.stack = []
+        HTMLParser.close(self)
+
+    def emit_style(self, style=None):
+        """
+        Emit an ANSI escape sequence for the given or current style to the output stream.
+
+        :param style: A dictionary with arguments for :func:`.ansi_style()` or
+                      :data:`None`, in which case the style at the top of the
+                      stack is emitted.
+        """
+        # Clear the current text styles.
+        self.output.write(ANSI_RESET)
+        # Apply a new text style?
+        style = self.current_style if style is None else style
+        if style:
+            self.output.write(ansi_style(**style))
+
+    def handle_charref(self, value):
+        """
+        Process a decimal or hexadecimal numeric character reference.
+
+        :param value: The decimal or hexadecimal value (a string).
+        """
+        self.output.write(unichr(int(value[1:], 16) if value.startswith('x') else int(value)))
+
+    def handle_data(self, data):
+        """
+        Process textual data.
+
+        :param data: The decoded text (a string).
+        """
+        if self.link_url:
+            # Link text is captured literally so that we can reliably check
+            # whether the text and the URL of the link are the same string.
+            self.link_text = data
+        elif self.callback and self.preformatted_text_level == 0:
+            # Text that is not part of a link and not preformatted text is
+            # passed to the user defined callback to allow for arbitrary
+            # pre-processing.
+            data = self.callback(data)
+        # All text is emitted unmodified on the output stream.
+        self.output.write(data)
+
+    def handle_endtag(self, tag):
+        """
+        Process the end of an HTML tag.
+
+        :param tag: The name of the tag (a string).
+        """
+        if tag in ('a', 'b', 'code', 'del', 'em', 'i', 'ins', 'pre', 's', 'strong', 'span', 'u'):
+            old_style = self.current_style
+            # The following conditional isn't necessary for well formed
+            # HTML but prevents raising exceptions on malformed HTML.
+            if self.stack:
+                self.stack.pop(-1)
+            new_style = self.current_style
+            if tag == 'a':
+                if self.urls_match(self.link_text, self.link_url):
+                    # Don't render the URL when it's part of the link text.
+                    self.emit_style(new_style)
+                else:
+                    self.emit_style(new_style)
+                    self.output.write(' (')
+                    self.emit_style(old_style)
+                    self.output.write(self.render_url(self.link_url))
+                    self.emit_style(new_style)
+                    self.output.write(')')
+            else:
+                self.emit_style(new_style)
+            if tag in ('code', 'pre'):
+                self.preformatted_text_level -= 1
+        if tag in self.BLOCK_TAGS:
+            # Emit an empty line after block level tags.
+            self.output.write('\n\n')
+
+    def handle_entityref(self, name):
+        """
+        Process a named character reference.
+
+        :param name: The name of the character reference (a string).
+        """
+        self.output.write(unichr(name2codepoint[name]))
+
+    def handle_starttag(self, tag, attrs):
+        """
+        Process the start of an HTML tag.
+
+        :param tag: The name of the tag (a string).
+        :param attrs: A list of tuples with two strings each.
+        """
+        if tag in self.BLOCK_TAGS:
+            # Emit an empty line before block level tags.
+            self.output.write('\n\n')
+        if tag == 'a':
+            self.push_styles(color='blue', bright=True, underline=True)
+            # Store the URL that the link points to for later use, so that we
+            # can render the link text before the URL (with the reasoning that
+            # this is the most intuitive way to present a link in a plain text
+            # interface).
+            self.link_url = next((v for n, v in attrs if n == 'href'), '')
+        elif tag == 'b' or tag == 'strong':
+            self.push_styles(bold=True)
+        elif tag == 'br':
+            self.output.write('\n')
+        elif tag == 'code' or tag == 'pre':
+            self.push_styles(color='yellow')
+            self.preformatted_text_level += 1
+        elif tag == 'del' or tag == 's':
+            self.push_styles(strike_through=True)
+        elif tag == 'em' or tag == 'i':
+            self.push_styles(italic=True)
+        elif tag == 'ins' or tag == 'u':
+            self.push_styles(underline=True)
+        elif tag == 'span':
+            styles = {}
+            css = next((v for n, v in attrs if n == 'style'), "")
+            for rule in css.split(';'):
+                name, _, value = rule.partition(':')
+                name = name.strip()
+                value = value.strip()
+                if name == 'background-color':
+                    styles['background'] = self.parse_color(value)
+                elif name == 'color':
+                    styles['color'] = self.parse_color(value)
+                elif name == 'font-style' and value == 'italic':
+                    styles['italic'] = True
+                elif name == 'font-weight' and value == 'bold':
+                    styles['bold'] = True
+                elif name == 'text-decoration' and value == 'line-through':
+                    styles['strike_through'] = True
+                elif name == 'text-decoration' and value == 'underline':
+                    styles['underline'] = True
+            self.push_styles(**styles)
+
+    def normalize_url(self, url):
+        """
+        Normalize a URL to enable string equality comparison.
+
+        :param url: The URL to normalize (a string).
+        :returns: The normalized URL (a string).
+        """
+        return re.sub('^mailto:', '', url)
+
+    def parse_color(self, value):
+        """
+        Convert a CSS color to something that :func:`.ansi_style()` understands.
+
+        :param value: A string like ``rgb(1,2,3)``, ``#AABBCC`` or ``yellow``.
+        :returns: A color value supported by :func:`.ansi_style()` or :data:`None`.
+        """
+        # Parse an 'rgb(N,N,N)' expression.
+        if value.startswith('rgb'):
+            tokens = re.findall(r'\d+', value)
+            if len(tokens) == 3:
+                return tuple(map(int, tokens))
+        # Parse an '#XXXXXX' expression.
+        elif value.startswith('#'):
+            value = value[1:]
+            length = len(value)
+            if length == 6:
+                # Six hex digits (proper notation).
+                return (
+                    int(value[:2], 16),
+                    int(value[2:4], 16),
+                    int(value[4:6], 16),
+                )
+            elif length == 3:
+                # Three hex digits (shorthand).
+                return (
+                    int(value[0], 16),
+                    int(value[1], 16),
+                    int(value[2], 16),
+                )
+        # Try to recognize a named color.
+        value = value.lower()
+        if value in ANSI_COLOR_CODES:
+            return value
+
+    def push_styles(self, **changes):
+        """
+        Push new style information onto the stack.
+
+        :param changes: Any keyword arguments are passed on to :func:`.ansi_style()`.
+
+        This method is a helper for :func:`handle_starttag()`
+        that does the following:
+
+        1. Make a copy of the current styles (from the top of the stack),
+        2. Apply the given `changes` to the copy of the current styles,
+        3. Add the new styles to the stack,
+        4. Emit the appropriate ANSI escape sequence to the output stream.
+        """
+        prototype = self.current_style
+        if prototype:
+            new_style = dict(prototype)
+            new_style.update(changes)
+        else:
+            new_style = changes
+        self.stack.append(new_style)
+        self.emit_style(new_style)
+
+    def render_url(self, url):
+        """
+        Prepare a URL for rendering on the terminal.
+
+        :param url: The URL to simplify (a string).
+        :returns: The simplified URL (a string).
+
+        This method pre-processes a URL before rendering on the terminal. The
+        following modifications are made:
+
+        - The ``mailto:`` prefix is stripped.
+        - Spaces are converted to ``%20``.
+        - A trailing parenthesis is converted to ``%29``.
+        """
+        url = re.sub('^mailto:', '', url)
+        url = re.sub(' ', '%20', url)
+        url = re.sub(r'\)$', '%29', url)
+        return url
+
+    def reset(self):
+        """
+        Reset the state of the HTML parser and ANSI converter.
+
+        When `output` is a :class:`~python3:io.StringIO` object a new
+        instance will be created (and the old one garbage collected).
+        """
+        # Reset the state of the superclass.
+        HTMLParser.reset(self)
+        # Reset our instance variables.
+        self.link_text = None
+        self.link_url = None
+        self.preformatted_text_level = 0
+        if self.output is None or isinstance(self.output, StringIO):
+            # If the caller specified something like output=sys.stdout then it
+            # doesn't make much sense to negate that choice here in reset().
+            self.output = StringIO()
+        self.stack = []
+
+    def urls_match(self, a, b):
+        """
+        Compare two URLs for equality using :func:`normalize_url()`.
+
+        :param a: A string containing a URL.
+        :param b: A string containing a URL.
+        :returns: :data:`True` if the URLs are the same, :data:`False` otherwise.
+
+        This method is used by :func:`handle_endtag()` to omit the URL of a
+        hyperlink (``<a href="...">``) when the link text is that same URL.
+        """
+        return self.normalize_url(a) == self.normalize_url(b)

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/terminal/spinners.py

@@ -0,0 +1,310 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: March 1, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Support for spinners that represent progress on interactive terminals.
+
+The :class:`Spinner` class shows a "spinner" on the terminal to let the user
+know that something is happening during long running operations that would
+otherwise be silent (leaving the user to wonder what they're waiting for).
+Below are some visual examples that should illustrate the point.
+
+**Simple spinners:**
+
+ Here's a screen capture that shows the simplest form of spinner:
+
+  .. image:: images/spinner-basic.gif
+     :alt: Animated screen capture of a simple spinner.
+
+ The following code was used to create the spinner above:
+
+ .. code-block:: python
+
+    import itertools
+    import time
+    from humanfriendly import Spinner
+
+    with Spinner(label="Downloading") as spinner:
+        for i in itertools.count():
+            # Do something useful here.
+            time.sleep(0.1)
+            # Advance the spinner.
+            spinner.step()
+
+**Spinners that show elapsed time:**
+
+ Here's a spinner that shows the elapsed time since it started:
+
+  .. image:: images/spinner-with-timer.gif
+     :alt: Animated screen capture of a spinner showing elapsed time.
+
+ The following code was used to create the spinner above:
+
+ .. code-block:: python
+
+    import itertools
+    import time
+    from humanfriendly import Spinner, Timer
+
+    with Spinner(label="Downloading", timer=Timer()) as spinner:
+        for i in itertools.count():
+            # Do something useful here.
+            time.sleep(0.1)
+            # Advance the spinner.
+            spinner.step()
+
+**Spinners that show progress:**
+
+ Here's a spinner that shows a progress percentage:
+
+  .. image:: images/spinner-with-progress.gif
+     :alt: Animated screen capture of spinner showing progress.
+
+ The following code was used to create the spinner above:
+
+ .. code-block:: python
+
+    import itertools
+    import random
+    import time
+    from humanfriendly import Spinner, Timer
+
+    with Spinner(label="Downloading", total=100) as spinner:
+        progress = 0
+        while progress < 100:
+            # Do something useful here.
+            time.sleep(0.1)
+            # Advance the spinner.
+            spinner.step(progress)
+            # Determine the new progress value.
+            progress += random.random() * 5
+
+If you want to provide user feedback during a long running operation but it's
+not practical to periodically call the :func:`~Spinner.step()` method consider
+using :class:`AutomaticSpinner` instead.
+
+As you may already have noticed in the examples above, :class:`Spinner` objects
+can be used as context managers to automatically call :func:`Spinner.clear()`
+when the spinner ends.
+"""
+
+# Standard library modules.
+import multiprocessing
+import sys
+import time
+
+# Modules included in our package.
+from humanfriendly import Timer
+from humanfriendly.deprecation import deprecated_args
+from humanfriendly.terminal import ANSI_ERASE_LINE
+
+# Public identifiers that require documentation.
+__all__ = ("AutomaticSpinner", "GLYPHS", "MINIMUM_INTERVAL", "Spinner")
+
+GLYPHS = ["-", "\\", "|", "/"]
+"""A list of strings with characters that together form a crude animation :-)."""
+
+MINIMUM_INTERVAL = 0.2
+"""Spinners are redrawn with a frequency no higher than this number (a floating point number of seconds)."""
+
+
+class Spinner(object):
+
+    """Show a spinner on the terminal as a simple means of feedback to the user."""
+
+    @deprecated_args('label', 'total', 'stream', 'interactive', 'timer')
+    def __init__(self, **options):
+        """
+        Initialize a :class:`Spinner` object.
+
+        :param label:
+
+          The label for the spinner (a string or :data:`None`, defaults to
+          :data:`None`).
+
+        :param total:
+
+          The expected number of steps (an integer or :data:`None`). If this is
+          provided the spinner will show a progress percentage.
+
+        :param stream:
+
+          The output stream to show the spinner on (a file-like object,
+          defaults to :data:`sys.stderr`).
+
+        :param interactive:
+
+          :data:`True` to enable rendering of the spinner, :data:`False` to
+          disable (defaults to the result of ``stream.isatty()``).
+
+        :param timer:
+
+          A :class:`.Timer` object (optional). If this is given the spinner
+          will show the elapsed time according to the timer.
+
+        :param interval:
+
+          The spinner will be updated at most once every this many seconds
+          (a floating point number, defaults to :data:`MINIMUM_INTERVAL`).
+
+        :param glyphs:
+
+          A list of strings with single characters that are drawn in the same
+          place in succession to implement a simple animated effect (defaults
+          to :data:`GLYPHS`).
+        """
+        # Store initializer arguments.
+        self.interactive = options.get('interactive')
+        self.interval = options.get('interval', MINIMUM_INTERVAL)
+        self.label = options.get('label')
+        self.states = options.get('glyphs', GLYPHS)
+        self.stream = options.get('stream', sys.stderr)
+        self.timer = options.get('timer')
+        self.total = options.get('total')
+        # Define instance variables.
+        self.counter = 0
+        self.last_update = 0
+        # Try to automatically discover whether the stream is connected to
+        # a terminal, but don't fail if no isatty() method is available.
+        if self.interactive is None:
+            try:
+                self.interactive = self.stream.isatty()
+            except Exception:
+                self.interactive = False
+
+    def step(self, progress=0, label=None):
+        """
+        Advance the spinner by one step and redraw it.
+
+        :param progress: The number of the current step, relative to the total
+                         given to the :class:`Spinner` constructor (an integer,
+                         optional). If not provided the spinner will not show
+                         progress.
+        :param label: The label to use while redrawing (a string, optional). If
+                      not provided the label given to the :class:`Spinner`
+                      constructor is used instead.
+
+        This method advances the spinner by one step without starting a new
+        line, causing an animated effect which is very simple but much nicer
+        than waiting for a prompt which is completely silent for a long time.
+
+        .. note:: This method uses time based rate limiting to avoid redrawing
+                  the spinner too frequently. If you know you're dealing with
+                  code that will call :func:`step()` at a high frequency,
+                  consider using :func:`sleep()` to avoid creating the
+                  equivalent of a busy loop that's rate limiting the spinner
+                  99% of the time.
+        """
+        if self.interactive:
+            time_now = time.time()
+            if time_now - self.last_update >= self.interval:
+                self.last_update = time_now
+                state = self.states[self.counter % len(self.states)]
+                label = label or self.label
+                if not label:
+                    raise Exception("No label set for spinner!")
+                elif self.total and progress:
+                    label = "%s: %.2f%%" % (label, progress / (self.total / 100.0))
+                elif self.timer and self.timer.elapsed_time > 2:
+                    label = "%s (%s)" % (label, self.timer.rounded)
+                self.stream.write("%s %s %s ..\r" % (ANSI_ERASE_LINE, state, label))
+                self.counter += 1
+
+    def sleep(self):
+        """
+        Sleep for a short period before redrawing the spinner.
+
+        This method is useful when you know you're dealing with code that will
+        call :func:`step()` at a high frequency. It will sleep for the interval
+        with which the spinner is redrawn (less than a second). This avoids
+        creating the equivalent of a busy loop that's rate limiting the
+        spinner 99% of the time.
+
+        This method doesn't redraw the spinner, you still have to call
+        :func:`step()` in order to do that.
+        """
+        time.sleep(MINIMUM_INTERVAL)
+
+    def clear(self):
+        """
+        Clear the spinner.
+
+        The next line which is shown on the standard output or error stream
+        after calling this method will overwrite the line that used to show the
+        spinner.
+        """
+        if self.interactive:
+            self.stream.write(ANSI_ERASE_LINE)
+
+    def __enter__(self):
+        """
+        Enable the use of spinners as context managers.
+
+        :returns: The :class:`Spinner` object.
+        """
+        return self
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Clear the spinner when leaving the context."""
+        self.clear()
+
+
+class AutomaticSpinner(object):
+
+    """
+    Show a spinner on the terminal that automatically starts animating.
+
+    This class shows a spinner on the terminal (just like :class:`Spinner`
+    does) that automatically starts animating. This class should be used as a
+    context manager using the :keyword:`with` statement. The animation
+    continues for as long as the context is active.
+
+    :class:`AutomaticSpinner` provides an alternative to :class:`Spinner`
+    for situations where it is not practical for the caller to periodically
+    call :func:`~Spinner.step()` to advance the animation, e.g. because
+    you're performing a blocking call and don't fancy implementing threading or
+    subprocess handling just to provide some user feedback.
+
+    This works using the :mod:`multiprocessing` module by spawning a
+    subprocess to render the spinner while the main process is busy doing
+    something more useful. By using the :keyword:`with` statement you're
+    guaranteed that the subprocess is properly terminated at the appropriate
+    time.
+    """
+
+    def __init__(self, label, show_time=True):
+        """
+        Initialize an automatic spinner.
+
+        :param label: The label for the spinner (a string).
+        :param show_time: If this is :data:`True` (the default) then the spinner
+                          shows elapsed time.
+        """
+        self.label = label
+        self.show_time = show_time
+        self.shutdown_event = multiprocessing.Event()
+        self.subprocess = multiprocessing.Process(target=self._target)
+
+    def __enter__(self):
+        """Enable the use of automatic spinners as context managers."""
+        self.subprocess.start()
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Enable the use of automatic spinners as context managers."""
+        self.shutdown_event.set()
+        self.subprocess.join()
+
+    def _target(self):
+        try:
+            timer = Timer() if self.show_time else None
+            with Spinner(label=self.label, timer=timer) as spinner:
+                while not self.shutdown_event.is_set():
+                    spinner.step()
+                    spinner.sleep()
+        except KeyboardInterrupt:
+            # Swallow Control-C signals without producing a nasty traceback that
+            # won't make any sense to the average user.
+            pass

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/testing.py

@@ -0,0 +1,669 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: March 6, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Utility classes and functions that make it easy to write :mod:`unittest` compatible test suites.
+
+Over the years I've developed the habit of writing test suites for Python
+projects using the :mod:`unittest` module. During those years I've come to know
+:pypi:`pytest` and in fact I use :pypi:`pytest` to run my test suites (due to
+its much better error reporting) but I've yet to publish a test suite that
+*requires* :pypi:`pytest`. I have several reasons for doing so:
+
+- It's nice to keep my test suites as simple and accessible as possible and
+  not requiring a specific test runner is part of that attitude.
+
+- Whereas :mod:`unittest` is quite explicit, :pypi:`pytest` contains a lot of
+  magic, which kind of contradicts the Python mantra "explicit is better than
+  implicit" (IMHO).
+"""
+
+# Standard library module
+import functools
+import logging
+import os
+import pipes
+import shutil
+import sys
+import tempfile
+import time
+import unittest
+
+# Modules included in our package.
+from humanfriendly.compat import StringIO
+from humanfriendly.text import random_string
+
+# Initialize a logger for this module.
+logger = logging.getLogger(__name__)
+
+# A unique object reference used to detect missing attributes.
+NOTHING = object()
+
+# Public identifiers that require documentation.
+__all__ = (
+    'CallableTimedOut',
+    'CaptureBuffer',
+    'CaptureOutput',
+    'ContextManager',
+    'CustomSearchPath',
+    'MockedProgram',
+    'PatchedAttribute',
+    'PatchedItem',
+    'TemporaryDirectory',
+    'TestCase',
+    'configure_logging',
+    'make_dirs',
+    'retry',
+    'run_cli',
+    'skip_on_raise',
+    'touch',
+)
+
+
+def configure_logging(log_level=logging.DEBUG):
+    """configure_logging(log_level=logging.DEBUG)
+    Automatically configure logging to the terminal.
+
+    :param log_level: The log verbosity (a number, defaults
+                      to :mod:`logging.DEBUG <logging>`).
+
+    When :mod:`coloredlogs` is installed :func:`coloredlogs.install()` will be
+    used to configure logging to the terminal. When this fails with an
+    :exc:`~exceptions.ImportError` then :func:`logging.basicConfig()` is used
+    as a fall back.
+    """
+    try:
+        import coloredlogs
+        coloredlogs.install(level=log_level)
+    except ImportError:
+        logging.basicConfig(
+            level=log_level,
+            format='%(asctime)s %(name)s[%(process)d] %(levelname)s %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S')
+
+
+def make_dirs(pathname):
+    """
+    Create missing directories.
+
+    :param pathname: The pathname of a directory (a string).
+    """
+    if not os.path.isdir(pathname):
+        os.makedirs(pathname)
+
+
+def retry(func, timeout=60, exc_type=AssertionError):
+    """retry(func, timeout=60, exc_type=AssertionError)
+    Retry a function until assertions no longer fail.
+
+    :param func: A callable. When the callable returns
+                 :data:`False` it will also be retried.
+    :param timeout: The number of seconds after which to abort (a number,
+                    defaults to 60).
+    :param exc_type: The type of exceptions to retry (defaults
+                     to :exc:`~exceptions.AssertionError`).
+    :returns: The value returned by `func`.
+    :raises: Once the timeout has expired :func:`retry()` will raise the
+             previously retried assertion error. When `func` keeps returning
+             :data:`False` until `timeout` expires :exc:`CallableTimedOut`
+             will be raised.
+
+    This function sleeps between retries to avoid claiming CPU cycles we don't
+    need. It starts by sleeping for 0.1 second but adjusts this to one second
+    as the number of retries grows.
+    """
+    pause = 0.1
+    timeout += time.time()
+    while True:
+        try:
+            result = func()
+            if result is not False:
+                return result
+        except exc_type:
+            if time.time() > timeout:
+                raise
+        else:
+            if time.time() > timeout:
+                raise CallableTimedOut()
+        time.sleep(pause)
+        if pause < 1:
+            pause *= 2
+
+
+def run_cli(entry_point, *arguments, **options):
+    """
+    Test a command line entry point.
+
+    :param entry_point: The function that implements the command line interface
+                        (a callable).
+    :param arguments: Any positional arguments (strings) become the command
+                      line arguments (:data:`sys.argv` items 1-N).
+    :param options: The following keyword arguments are supported:
+
+                    **capture**
+                     Whether to use :class:`CaptureOutput`. Defaults
+                     to :data:`True` but can be disabled by passing
+                     :data:`False` instead.
+                    **input**
+                     Refer to :class:`CaptureOutput`.
+                    **merged**
+                     Refer to :class:`CaptureOutput`.
+                    **program_name**
+                     Used to set :data:`sys.argv` item 0.
+    :returns: A tuple with two values:
+
+              1. The return code (an integer).
+              2. The captured output (a string).
+    """
+    # Add the `program_name' option to the arguments.
+    arguments = list(arguments)
+    arguments.insert(0, options.pop('program_name', sys.executable))
+    # Log the command line arguments (and the fact that we're about to call the
+    # command line entry point function).
+    logger.debug("Calling command line entry point with arguments: %s", arguments)
+    # Prepare to capture the return code and output even if the command line
+    # interface raises an exception (whether the exception type is SystemExit
+    # or something else).
+    returncode = 0
+    stdout = None
+    stderr = None
+    try:
+        # Temporarily override sys.argv.
+        with PatchedAttribute(sys, 'argv', arguments):
+            # Manipulate the standard input/output/error streams?
+            options['enabled'] = options.pop('capture', True)
+            with CaptureOutput(**options) as capturer:
+                try:
+                    # Call the command line interface.
+                    entry_point()
+                finally:
+                    # Get the output even if an exception is raised.
+                    stdout = capturer.stdout.getvalue()
+                    stderr = capturer.stderr.getvalue()
+                    # Reconfigure logging to the terminal because it is very
+                    # likely that the entry point function has changed the
+                    # configured log level.
+                    configure_logging()
+    except BaseException as e:
+        if isinstance(e, SystemExit):
+            logger.debug("Intercepting return code %s from SystemExit exception.", e.code)
+            returncode = e.code
+        else:
+            logger.warning("Defaulting return code to 1 due to raised exception.", exc_info=True)
+            returncode = 1
+    else:
+        logger.debug("Command line entry point returned successfully!")
+    # Always log the output captured on stdout/stderr, to make it easier to
+    # diagnose test failures (but avoid duplicate logging when merged=True).
+    is_merged = options.get('merged', False)
+    merged_streams = [('merged streams', stdout)]
+    separate_streams = [('stdout', stdout), ('stderr', stderr)]
+    streams = merged_streams if is_merged else separate_streams
+    for name, value in streams:
+        if value:
+            logger.debug("Output on %s:\n%s", name, value)
+        else:
+            logger.debug("No output on %s.", name)
+    return returncode, stdout
+
+
+def skip_on_raise(*exc_types):
+    """
+    Decorate a test function to translation specific exception types to :exc:`unittest.SkipTest`.
+
+    :param exc_types: One or more positional arguments give the exception
+                      types to be translated to :exc:`unittest.SkipTest`.
+    :returns: A decorator function specialized to `exc_types`.
+    """
+    def decorator(function):
+        @functools.wraps(function)
+        def wrapper(*args, **kw):
+            try:
+                return function(*args, **kw)
+            except exc_types as e:
+                logger.debug("Translating exception to unittest.SkipTest ..", exc_info=True)
+                raise unittest.SkipTest("skipping test because %s was raised" % type(e))
+        return wrapper
+    return decorator
+
+
+def touch(filename):
+    """
+    The equivalent of the UNIX :man:`touch` program in Python.
+
+    :param filename: The pathname of the file to touch (a string).
+
+    Note that missing directories are automatically created using
+    :func:`make_dirs()`.
+    """
+    make_dirs(os.path.dirname(filename))
+    with open(filename, 'a'):
+        os.utime(filename, None)
+
+
+class CallableTimedOut(Exception):
+
+    """Raised by :func:`retry()` when the timeout expires."""
+
+
+class ContextManager(object):
+
+    """Base class to enable composition of context managers."""
+
+    def __enter__(self):
+        """Enable use as context managers."""
+        return self
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Enable use as context managers."""
+
+
+class PatchedAttribute(ContextManager):
+
+    """Context manager that temporary replaces an object attribute using :func:`setattr()`."""
+
+    def __init__(self, obj, name, value):
+        """
+        Initialize a :class:`PatchedAttribute` object.
+
+        :param obj: The object to patch.
+        :param name: An attribute name.
+        :param value: The value to set.
+        """
+        self.object_to_patch = obj
+        self.attribute_to_patch = name
+        self.patched_value = value
+        self.original_value = NOTHING
+
+    def __enter__(self):
+        """
+        Replace (patch) the attribute.
+
+        :returns: The object whose attribute was patched.
+        """
+        # Enable composition of context managers.
+        super(PatchedAttribute, self).__enter__()
+        # Patch the object's attribute.
+        self.original_value = getattr(self.object_to_patch, self.attribute_to_patch, NOTHING)
+        setattr(self.object_to_patch, self.attribute_to_patch, self.patched_value)
+        return self.object_to_patch
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Restore the attribute to its original value."""
+        # Enable composition of context managers.
+        super(PatchedAttribute, self).__exit__(exc_type, exc_value, traceback)
+        # Restore the object's attribute.
+        if self.original_value is NOTHING:
+            delattr(self.object_to_patch, self.attribute_to_patch)
+        else:
+            setattr(self.object_to_patch, self.attribute_to_patch, self.original_value)
+
+
+class PatchedItem(ContextManager):
+
+    """Context manager that temporary replaces an object item using :meth:`~object.__setitem__()`."""
+
+    def __init__(self, obj, item, value):
+        """
+        Initialize a :class:`PatchedItem` object.
+
+        :param obj: The object to patch.
+        :param item: The item to patch.
+        :param value: The value to set.
+        """
+        self.object_to_patch = obj
+        self.item_to_patch = item
+        self.patched_value = value
+        self.original_value = NOTHING
+
+    def __enter__(self):
+        """
+        Replace (patch) the item.
+
+        :returns: The object whose item was patched.
+        """
+        # Enable composition of context managers.
+        super(PatchedItem, self).__enter__()
+        # Patch the object's item.
+        try:
+            self.original_value = self.object_to_patch[self.item_to_patch]
+        except KeyError:
+            self.original_value = NOTHING
+        self.object_to_patch[self.item_to_patch] = self.patched_value
+        return self.object_to_patch
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Restore the item to its original value."""
+        # Enable composition of context managers.
+        super(PatchedItem, self).__exit__(exc_type, exc_value, traceback)
+        # Restore the object's item.
+        if self.original_value is NOTHING:
+            del self.object_to_patch[self.item_to_patch]
+        else:
+            self.object_to_patch[self.item_to_patch] = self.original_value
+
+
+class TemporaryDirectory(ContextManager):
+
+    """
+    Easy temporary directory creation & cleanup using the :keyword:`with` statement.
+
+    Here's an example of how to use this:
+
+    .. code-block:: python
+
+       with TemporaryDirectory() as directory:
+           # Do something useful here.
+           assert os.path.isdir(directory)
+    """
+
+    def __init__(self, **options):
+        """
+        Initialize a :class:`TemporaryDirectory` object.
+
+        :param options: Any keyword arguments are passed on to
+                        :func:`tempfile.mkdtemp()`.
+        """
+        self.mkdtemp_options = options
+        self.temporary_directory = None
+
+    def __enter__(self):
+        """
+        Create the temporary directory using :func:`tempfile.mkdtemp()`.
+
+        :returns: The pathname of the directory (a string).
+        """
+        # Enable composition of context managers.
+        super(TemporaryDirectory, self).__enter__()
+        # Create the temporary directory.
+        self.temporary_directory = tempfile.mkdtemp(**self.mkdtemp_options)
+        return self.temporary_directory
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Cleanup the temporary directory using :func:`shutil.rmtree()`."""
+        # Enable composition of context managers.
+        super(TemporaryDirectory, self).__exit__(exc_type, exc_value, traceback)
+        # Cleanup the temporary directory.
+        if self.temporary_directory is not None:
+            shutil.rmtree(self.temporary_directory)
+            self.temporary_directory = None
+
+
+class MockedHomeDirectory(PatchedItem, TemporaryDirectory):
+
+    """
+    Context manager to temporarily change ``$HOME`` (the current user's profile directory).
+
+    This class is a composition of the :class:`PatchedItem` and
+    :class:`TemporaryDirectory` context managers.
+    """
+
+    def __init__(self):
+        """Initialize a :class:`MockedHomeDirectory` object."""
+        PatchedItem.__init__(self, os.environ, 'HOME', os.environ.get('HOME'))
+        TemporaryDirectory.__init__(self)
+
+    def __enter__(self):
+        """
+        Activate the custom ``$PATH``.
+
+        :returns: The pathname of the directory that has
+                  been added to ``$PATH`` (a string).
+        """
+        # Get the temporary directory.
+        directory = TemporaryDirectory.__enter__(self)
+        # Override the value to patch now that we have
+        # the pathname of the temporary directory.
+        self.patched_value = directory
+        # Temporary patch $HOME.
+        PatchedItem.__enter__(self)
+        # Pass the pathname of the temporary directory to the caller.
+        return directory
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Deactivate the custom ``$HOME``."""
+        super(MockedHomeDirectory, self).__exit__(exc_type, exc_value, traceback)
+
+
+class CustomSearchPath(PatchedItem, TemporaryDirectory):
+
+    """
+    Context manager to temporarily customize ``$PATH`` (the executable search path).
+
+    This class is a composition of the :class:`PatchedItem` and
+    :class:`TemporaryDirectory` context managers.
+    """
+
+    def __init__(self, isolated=False):
+        """
+        Initialize a :class:`CustomSearchPath` object.
+
+        :param isolated: :data:`True` to clear the original search path,
+                         :data:`False` to add the temporary directory to the
+                         start of the search path.
+        """
+        # Initialize our own instance variables.
+        self.isolated_search_path = isolated
+        # Selectively initialize our superclasses.
+        PatchedItem.__init__(self, os.environ, 'PATH', self.current_search_path)
+        TemporaryDirectory.__init__(self)
+
+    def __enter__(self):
+        """
+        Activate the custom ``$PATH``.
+
+        :returns: The pathname of the directory that has
+                  been added to ``$PATH`` (a string).
+        """
+        # Get the temporary directory.
+        directory = TemporaryDirectory.__enter__(self)
+        # Override the value to patch now that we have
+        # the pathname of the temporary directory.
+        self.patched_value = (
+            directory if self.isolated_search_path
+            else os.pathsep.join([directory] + self.current_search_path.split(os.pathsep))
+        )
+        # Temporary patch the $PATH.
+        PatchedItem.__enter__(self)
+        # Pass the pathname of the temporary directory to the caller
+        # because they may want to `install' custom executables.
+        return directory
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Deactivate the custom ``$PATH``."""
+        super(CustomSearchPath, self).__exit__(exc_type, exc_value, traceback)
+
+    @property
+    def current_search_path(self):
+        """The value of ``$PATH`` or :data:`os.defpath` (a string)."""
+        return os.environ.get('PATH', os.defpath)
+
+
+class MockedProgram(CustomSearchPath):
+
+    """
+    Context manager to mock the existence of a program (executable).
+
+    This class extends the functionality of :class:`CustomSearchPath`.
+    """
+
+    def __init__(self, name, returncode=0, script=None):
+        """
+        Initialize a :class:`MockedProgram` object.
+
+        :param name: The name of the program (a string).
+        :param returncode: The return code that the program should emit (a
+                           number, defaults to zero).
+        :param script: Shell script code to include in the mocked program (a
+                       string or :data:`None`). This can be used to mock a
+                       program that is expected to generate specific output.
+        """
+        # Initialize our own instance variables.
+        self.program_name = name
+        self.program_returncode = returncode
+        self.program_script = script
+        self.program_signal_file = None
+        # Initialize our superclasses.
+        super(MockedProgram, self).__init__()
+
+    def __enter__(self):
+        """
+        Create the mock program.
+
+        :returns: The pathname of the directory that has
+                  been added to ``$PATH`` (a string).
+        """
+        directory = super(MockedProgram, self).__enter__()
+        self.program_signal_file = os.path.join(directory, 'program-was-run-%s' % random_string(10))
+        pathname = os.path.join(directory, self.program_name)
+        with open(pathname, 'w') as handle:
+            handle.write('#!/bin/sh\n')
+            handle.write('echo > %s\n' % pipes.quote(self.program_signal_file))
+            if self.program_script:
+                handle.write('%s\n' % self.program_script.strip())
+            handle.write('exit %i\n' % self.program_returncode)
+        os.chmod(pathname, 0o755)
+        return directory
+
+    def __exit__(self, *args, **kw):
+        """
+        Ensure that the mock program was run.
+
+        :raises: :exc:`~exceptions.AssertionError` when
+                 the mock program hasn't been run.
+        """
+        try:
+            assert self.program_signal_file and os.path.isfile(self.program_signal_file), \
+                ("It looks like %r was never run!" % self.program_name)
+        finally:
+            return super(MockedProgram, self).__exit__(*args, **kw)
+
+
+class CaptureOutput(ContextManager):
+
+    """
+    Context manager that captures what's written to :data:`sys.stdout` and :data:`sys.stderr`.
+
+    .. attribute:: stdin
+
+       The :class:`~humanfriendly.compat.StringIO` object used to feed the standard input stream.
+
+    .. attribute:: stdout
+
+       The :class:`CaptureBuffer` object used to capture the standard output stream.
+
+    .. attribute:: stderr
+
+       The :class:`CaptureBuffer` object used to capture the standard error stream.
+    """
+
+    def __init__(self, merged=False, input='', enabled=True):
+        """
+        Initialize a :class:`CaptureOutput` object.
+
+        :param merged: :data:`True` to merge the streams,
+                       :data:`False` to capture them separately.
+        :param input: The data that reads from :data:`sys.stdin`
+                      should return (a string).
+        :param enabled: :data:`True` to enable capturing (the default),
+                        :data:`False` otherwise. This makes it easy to
+                        unconditionally use :class:`CaptureOutput` in
+                        a :keyword:`with` block while preserving the
+                        choice to opt out of capturing output.
+        """
+        self.stdin = StringIO(input)
+        self.stdout = CaptureBuffer()
+        self.stderr = self.stdout if merged else CaptureBuffer()
+        self.patched_attributes = []
+        if enabled:
+            self.patched_attributes.extend(
+                PatchedAttribute(sys, name, getattr(self, name))
+                for name in ('stdin', 'stdout', 'stderr')
+            )
+
+    def __enter__(self):
+        """Start capturing what's written to :data:`sys.stdout` and :data:`sys.stderr`."""
+        super(CaptureOutput, self).__enter__()
+        for context in self.patched_attributes:
+            context.__enter__()
+        return self
+
+    def __exit__(self, exc_type=None, exc_value=None, traceback=None):
+        """Stop capturing what's written to :data:`sys.stdout` and :data:`sys.stderr`."""
+        super(CaptureOutput, self).__exit__(exc_type, exc_value, traceback)
+        for context in self.patched_attributes:
+            context.__exit__(exc_type, exc_value, traceback)
+
+    def get_lines(self):
+        """Get the contents of :attr:`stdout` split into separate lines."""
+        return self.get_text().splitlines()
+
+    def get_text(self):
+        """Get the contents of :attr:`stdout` as a Unicode string."""
+        return self.stdout.get_text()
+
+    def getvalue(self):
+        """Get the text written to :data:`sys.stdout`."""
+        return self.stdout.getvalue()
+
+
+class CaptureBuffer(StringIO):
+
+    """
+    Helper for :class:`CaptureOutput` to provide an easy to use API.
+
+    The two methods defined by this subclass were specifically chosen to match
+    the names of the methods provided by my :pypi:`capturer` package which
+    serves a similar role as :class:`CaptureOutput` but knows how to simulate
+    an interactive terminal (tty).
+    """
+
+    def get_lines(self):
+        """Get the contents of the buffer split into separate lines."""
+        return self.get_text().splitlines()
+
+    def get_text(self):
+        """Get the contents of the buffer as a Unicode string."""
+        return self.getvalue()
+
+
+class TestCase(unittest.TestCase):
+
+    """Subclass of :class:`unittest.TestCase` with automatic logging and other miscellaneous features."""
+
+    def __init__(self, *args, **kw):
+        """
+        Initialize a :class:`TestCase` object.
+
+        Any positional and/or keyword arguments are passed on to the
+        initializer of the superclass.
+        """
+        super(TestCase, self).__init__(*args, **kw)
+
+    def setUp(self, log_level=logging.DEBUG):
+        """setUp(log_level=logging.DEBUG)
+        Automatically configure logging to the terminal.
+
+        :param log_level: Refer to :func:`configure_logging()`.
+
+        The :func:`setUp()` method is automatically called by
+        :class:`unittest.TestCase` before each test method starts.
+        It does two things:
+
+        - Logging to the terminal is configured using
+          :func:`configure_logging()`.
+
+        - Before the test method starts a newline is emitted, to separate the
+          name of the test method (which will be printed to the terminal by
+          :mod:`unittest` or :pypi:`pytest`) from the first line of logging
+          output that the test method is likely going to generate.
+        """
+        # Configure logging to the terminal.
+        configure_logging(log_level)
+        # Separate the name of the test method (printed by the superclass
+        # and/or py.test without a newline at the end) from the first line of
+        # logging output that the test method is likely going to generate.
+        sys.stderr.write("\n")

evalkit_tf446/lib/python3.10/site-packages/humanfriendly/text.py

@@ -0,0 +1,449 @@
+# Human friendly input/output in Python.
+#
+# Author: Peter Odding <peter@peterodding.com>
+# Last Change: December 1, 2020
+# URL: https://humanfriendly.readthedocs.io
+
+"""
+Simple text manipulation functions.
+
+The :mod:`~humanfriendly.text` module contains simple functions to manipulate text:
+
+- The :func:`concatenate()` and :func:`pluralize()` functions make it easy to
+  generate human friendly output.
+
+- The :func:`format()`, :func:`compact()` and :func:`dedent()` functions
+  provide a clean and simple to use syntax for composing large text fragments
+  with interpolated variables.
+
+- The :func:`tokenize()` function parses simple user input.
+"""
+
+# Standard library modules.
+import numbers
+import random
+import re
+import string
+import textwrap
+
+# Public identifiers that require documentation.
+__all__ = (
+    'compact',
+    'compact_empty_lines',
+    'concatenate',
+    'dedent',
+    'format',
+    'generate_slug',
+    'is_empty_line',
+    'join_lines',
+    'pluralize',
+    'pluralize_raw',
+    'random_string',
+    'split',
+    'split_paragraphs',
+    'tokenize',
+    'trim_empty_lines',
+)
+
+
+def compact(text, *args, **kw):
+    '''
+    Compact whitespace in a string.
+
+    Trims leading and trailing whitespace, replaces runs of whitespace
+    characters with a single space and interpolates any arguments using
+    :func:`format()`.
+
+    :param text: The text to compact (a string).
+    :param args: Any positional arguments are interpolated using :func:`format()`.
+    :param kw: Any keyword arguments are interpolated using :func:`format()`.
+    :returns: The compacted text (a string).
+
+    Here's an example of how I like to use the :func:`compact()` function, this
+    is an example from a random unrelated project I'm working on at the moment::
+
+        raise PortDiscoveryError(compact("""
+            Failed to discover port(s) that Apache is listening on!
+            Maybe I'm parsing the wrong configuration file? ({filename})
+        """, filename=self.ports_config))
+
+    The combination of :func:`compact()` and Python's multi line strings allows
+    me to write long text fragments with interpolated variables that are easy
+    to write, easy to read and work well with Python's whitespace
+    sensitivity.
+    '''
+    non_whitespace_tokens = text.split()
+    compacted_text = ' '.join(non_whitespace_tokens)
+    return format(compacted_text, *args, **kw)
+
+
+def compact_empty_lines(text):
+    """
+    Replace repeating empty lines with a single empty line (similar to ``cat -s``).
+
+    :param text: The text in which to compact empty lines (a string).
+    :returns: The text with empty lines compacted (a string).
+    """
+    i = 0
+    lines = text.splitlines(True)
+    while i < len(lines):
+        if i > 0 and is_empty_line(lines[i - 1]) and is_empty_line(lines[i]):
+            lines.pop(i)
+        else:
+            i += 1
+    return ''.join(lines)
+
+
+def concatenate(items, conjunction='and', serial_comma=False):
+    """
+    Concatenate a list of items in a human friendly way.
+
+    :param items:
+
+        A sequence of strings.
+
+    :param conjunction:
+
+        The word to use before the last item (a string, defaults to "and").
+
+    :param serial_comma:
+
+        :data:`True` to use a `serial comma`_, :data:`False` otherwise
+        (defaults to :data:`False`).
+
+    :returns:
+
+        A single string.
+
+    >>> from humanfriendly.text import concatenate
+    >>> concatenate(["eggs", "milk", "bread"])
+    'eggs, milk and bread'
+
+    .. _serial comma: https://en.wikipedia.org/wiki/Serial_comma
+    """
+    items = list(items)
+    if len(items) > 1:
+        final_item = items.pop()
+        formatted = ', '.join(items)
+        if serial_comma:
+            formatted += ','
+        return ' '.join([formatted, conjunction, final_item])
+    elif items:
+        return items[0]
+    else:
+        return ''
+
+
+def dedent(text, *args, **kw):
+    """
+    Dedent a string (remove common leading whitespace from all lines).
+
+    Removes common leading whitespace from all lines in the string using
+    :func:`textwrap.dedent()`, removes leading and trailing empty lines using
+    :func:`trim_empty_lines()` and interpolates any arguments using
+    :func:`format()`.
+
+    :param text: The text to dedent (a string).
+    :param args: Any positional arguments are interpolated using :func:`format()`.
+    :param kw: Any keyword arguments are interpolated using :func:`format()`.
+    :returns: The dedented text (a string).
+
+    The :func:`compact()` function's documentation contains an example of how I
+    like to use the :func:`compact()` and :func:`dedent()` functions. The main
+    difference is that I use :func:`compact()` for text that will be presented
+    to the user (where whitespace is not so significant) and :func:`dedent()`
+    for data file and code generation tasks (where newlines and indentation are
+    very significant).
+    """
+    dedented_text = textwrap.dedent(text)
+    trimmed_text = trim_empty_lines(dedented_text)
+    return format(trimmed_text, *args, **kw)
+
+
+def format(text, *args, **kw):
+    """
+    Format a string using the string formatting operator and/or :meth:`str.format()`.
+
+    :param text: The text to format (a string).
+    :param args: Any positional arguments are interpolated into the text using
+                 the string formatting operator (``%``). If no positional
+                 arguments are given no interpolation is done.
+    :param kw: Any keyword arguments are interpolated into the text using the
+               :meth:`str.format()` function. If no keyword arguments are given
+               no interpolation is done.
+    :returns: The text with any positional and/or keyword arguments
+              interpolated (a string).
+
+    The implementation of this function is so trivial that it seems silly to
+    even bother writing and documenting it. Justifying this requires some
+    context :-).
+
+    **Why format() instead of the string formatting operator?**
+
+    For really simple string interpolation Python's string formatting operator
+    is ideal, but it does have some strange quirks:
+
+    - When you switch from interpolating a single value to interpolating
+      multiple values you have to wrap them in tuple syntax. Because
+      :func:`format()` takes a `variable number of arguments`_ it always
+      receives a tuple (which saves me a context switch :-). Here's an
+      example:
+
+      >>> from humanfriendly.text import format
+      >>> # The string formatting operator.
+      >>> print('the magic number is %s' % 42)
+      the magic number is 42
+      >>> print('the magic numbers are %s and %s' % (12, 42))
+      the magic numbers are 12 and 42
+      >>> # The format() function.
+      >>> print(format('the magic number is %s', 42))
+      the magic number is 42
+      >>> print(format('the magic numbers are %s and %s', 12, 42))
+      the magic numbers are 12 and 42
+
+    - When you interpolate a single value and someone accidentally passes in a
+      tuple your code raises a :exc:`~exceptions.TypeError`. Because
+      :func:`format()` takes a `variable number of arguments`_ it always
+      receives a tuple so this can never happen. Here's an example:
+
+      >>> # How expecting to interpolate a single value can fail.
+      >>> value = (12, 42)
+      >>> print('the magic value is %s' % value)
+      Traceback (most recent call last):
+        File "<stdin>", line 1, in <module>
+      TypeError: not all arguments converted during string formatting
+      >>> # The following line works as intended, no surprises here!
+      >>> print(format('the magic value is %s', value))
+      the magic value is (12, 42)
+
+    **Why format() instead of the str.format() method?**
+
+    When you're doing complex string interpolation the :meth:`str.format()`
+    function results in more readable code, however I frequently find myself
+    adding parentheses to force evaluation order. The :func:`format()` function
+    avoids this because of the relative priority between the comma and dot
+    operators. Here's an example:
+
+    >>> "{adjective} example" + " " + "(can't think of anything less {adjective})".format(adjective='silly')
+    "{adjective} example (can't think of anything less silly)"
+    >>> ("{adjective} example" + " " + "(can't think of anything less {adjective})").format(adjective='silly')
+    "silly example (can't think of anything less silly)"
+    >>> format("{adjective} example" + " " + "(can't think of anything less {adjective})", adjective='silly')
+    "silly example (can't think of anything less silly)"
+
+    The :func:`compact()` and :func:`dedent()` functions are wrappers that
+    combine :func:`format()` with whitespace manipulation to make it easy to
+    write nice to read Python code.
+
+    .. _variable number of arguments: https://docs.python.org/2/tutorial/controlflow.html#arbitrary-argument-lists
+    """
+    if args:
+        text %= args
+    if kw:
+        text = text.format(**kw)
+    return text
+
+
+def generate_slug(text, delimiter="-"):
+    """
+    Convert text to a normalized "slug" without whitespace.
+
+    :param text: The original text, for example ``Some Random Text!``.
+    :param delimiter: The delimiter used to separate words
+                      (defaults to the ``-`` character).
+    :returns: The slug text, for example ``some-random-text``.
+    :raises: :exc:`~exceptions.ValueError` when the provided
+             text is nonempty but results in an empty slug.
+    """
+    slug = text.lower()
+    escaped = delimiter.replace("\\", "\\\\")
+    slug = re.sub("[^a-z0-9]+", escaped, slug)
+    slug = slug.strip(delimiter)
+    if text and not slug:
+        msg = "The provided text %r results in an empty slug!"
+        raise ValueError(format(msg, text))
+    return slug
+
+
+def is_empty_line(text):
+    """
+    Check if a text is empty or contains only whitespace.
+
+    :param text: The text to check for "emptiness" (a string).
+    :returns: :data:`True` if the text is empty or contains only whitespace,
+              :data:`False` otherwise.
+    """
+    return len(text) == 0 or text.isspace()
+
+
+def join_lines(text):
+    """
+    Remove "hard wrapping" from the paragraphs in a string.
+
+    :param text: The text to reformat (a string).
+    :returns: The text without hard wrapping (a string).
+
+    This function works by removing line breaks when the last character before
+    a line break and the first character after the line break are both
+    non-whitespace characters. This means that common leading indentation will
+    break :func:`join_lines()` (in that case you can use :func:`dedent()`
+    before calling :func:`join_lines()`).
+    """
+    return re.sub(r'(\S)\n(\S)', r'\1 \2', text)
+
+
+def pluralize(count, singular, plural=None):
+    """
+    Combine a count with the singular or plural form of a word.
+
+    :param count: The count (a number).
+    :param singular: The singular form of the word (a string).
+    :param plural: The plural form of the word (a string or :data:`None`).
+    :returns: The count and singular or plural word concatenated (a string).
+
+    See :func:`pluralize_raw()` for the logic underneath :func:`pluralize()`.
+    """
+    return '%s %s' % (count, pluralize_raw(count, singular, plural))
+
+
+def pluralize_raw(count, singular, plural=None):
+    """
+    Select the singular or plural form of a word based on a count.
+
+    :param count: The count (a number).
+    :param singular: The singular form of the word (a string).
+    :param plural: The plural form of the word (a string or :data:`None`).
+    :returns: The singular or plural form of the word (a string).
+
+    When the given count is exactly 1.0 the singular form of the word is
+    selected, in all other cases the plural form of the word is selected.
+
+    If the plural form of the word is not provided it is obtained by
+    concatenating the singular form of the word with the letter "s". Of course
+    this will not always be correct, which is why you have the option to
+    specify both forms.
+    """
+    if not plural:
+        plural = singular + 's'
+    return singular if float(count) == 1.0 else plural
+
+
+def random_string(length=(25, 100), characters=string.ascii_letters):
+    """random_string(length=(25, 100), characters=string.ascii_letters)
+    Generate a random string.
+
+    :param length: The length of the string to be generated (a number or a
+                   tuple with two numbers). If this is a tuple then a random
+                   number between the two numbers given in the tuple is used.
+    :param characters: The characters to be used (a string, defaults
+                       to :data:`string.ascii_letters`).
+    :returns: A random string.
+
+    The :func:`random_string()` function is very useful in test suites; by the
+    time I included it in :mod:`humanfriendly.text` I had already included
+    variants of this function in seven different test suites :-).
+    """
+    if not isinstance(length, numbers.Number):
+        length = random.randint(length[0], length[1])
+    return ''.join(random.choice(characters) for _ in range(length))
+
+
+def split(text, delimiter=','):
+    """
+    Split a comma-separated list of strings.
+
+    :param text: The text to split (a string).
+    :param delimiter: The delimiter to split on (a string).
+    :returns: A list of zero or more nonempty strings.
+
+    Here's the default behavior of Python's built in :meth:`str.split()`
+    function:
+
+    >>> 'foo,bar, baz,'.split(',')
+    ['foo', 'bar', ' baz', '']
+
+    In contrast here's the default behavior of the :func:`split()` function:
+
+    >>> from humanfriendly.text import split
+    >>> split('foo,bar, baz,')
+    ['foo', 'bar', 'baz']
+
+    Here is an example that parses a nested data structure (a mapping of
+    logging level names to one or more styles per level) that's encoded in a
+    string so it can be set as an environment variable:
+
+    >>> from pprint import pprint
+    >>> encoded_data = 'debug=green;warning=yellow;error=red;critical=red,bold'
+    >>> parsed_data = dict((k, split(v, ',')) for k, v in (split(kv, '=') for kv in split(encoded_data, ';')))
+    >>> pprint(parsed_data)
+    {'debug': ['green'],
+     'warning': ['yellow'],
+     'error': ['red'],
+     'critical': ['red', 'bold']}
+    """
+    return [token.strip() for token in text.split(delimiter) if token and not token.isspace()]
+
+
+def split_paragraphs(text):
+    """
+    Split a string into paragraphs (one or more lines delimited by an empty line).
+
+    :param text: The text to split into paragraphs (a string).
+    :returns: A list of strings.
+    """
+    paragraphs = []
+    for chunk in text.split('\n\n'):
+        chunk = trim_empty_lines(chunk)
+        if chunk and not chunk.isspace():
+            paragraphs.append(chunk)
+    return paragraphs
+
+
+def tokenize(text):
+    """
+    Tokenize a text into numbers and strings.
+
+    :param text: The text to tokenize (a string).
+    :returns: A list of strings and/or numbers.
+
+    This function is used to implement robust tokenization of user input in
+    functions like :func:`.parse_size()` and :func:`.parse_timespan()`. It
+    automatically coerces integer and floating point numbers, ignores
+    whitespace and knows how to separate numbers from strings even without
+    whitespace. Some examples to make this more concrete:
+
+    >>> from humanfriendly.text import tokenize
+    >>> tokenize('42')
+    [42]
+    >>> tokenize('42MB')
+    [42, 'MB']
+    >>> tokenize('42.5MB')
+    [42.5, 'MB']
+    >>> tokenize('42.5 MB')
+    [42.5, 'MB']
+    """
+    tokenized_input = []
+    for token in re.split(r'(\d+(?:\.\d+)?)', text):
+        token = token.strip()
+        if re.match(r'\d+\.\d+', token):
+            tokenized_input.append(float(token))
+        elif token.isdigit():
+            tokenized_input.append(int(token))
+        elif token:
+            tokenized_input.append(token)
+    return tokenized_input
+
+
+def trim_empty_lines(text):
+    """
+    Trim leading and trailing empty lines from the given text.
+
+    :param text: The text to trim (a string).
+    :returns: The trimmed text (a string).
+    """
+    lines = text.splitlines(True)
+    while lines and is_empty_line(lines[0]):
+        lines.pop(0)
+    while lines and is_empty_line(lines[-1]):
+        lines.pop(-1)
+    return ''.join(lines)

evalkit_tf446/lib/python3.10/site-packages/parso-0.8.4.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

evalkit_tf446/lib/python3.10/site-packages/parso-0.8.4.dist-info/LICENSE.txt

@@ -0,0 +1,86 @@
+All contributions towards parso are MIT licensed.
+
+Some Python files have been taken from the standard library and are therefore
+PSF licensed. Modifications on these files are dual licensed (both MIT and
+PSF). These files are:
+
+- parso/pgen2/*
+- parso/tokenize.py
+- parso/token.py
+- test/test_pgen2.py
+
+Also some test files under test/normalizer_issue_files have been copied from
+https://github.com/PyCQA/pycodestyle (Expat License == MIT License).
+
+-------------------------------------------------------------------------------
+The MIT License (MIT)
+
+Copyright (c) <2013-2017> <David Halter and others, see AUTHORS.txt>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+-------------------------------------------------------------------------------
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015 Python Software Foundation; All Rights Reserved"
+are retained in Python alone or in any derivative version prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.

evalkit_tf446/lib/python3.10/site-packages/parso-0.8.4.dist-info/METADATA

@@ -0,0 +1,287 @@
+Metadata-Version: 2.1
+Name: parso
+Version: 0.8.4
+Summary: A Python Parser
+Home-page: https://github.com/davidhalter/parso
+Author: David Halter
+Author-email: davidhalter88@gmail.com
+Maintainer: David Halter
+Maintainer-email: davidhalter88@gmail.com
+License: MIT
+Keywords: python parser parsing
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Plugins
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE)
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.6
+Provides-Extra: qa
+Requires-Dist: flake8 (==5.0.4) ; extra == 'qa'
+Requires-Dist: mypy (==0.971) ; extra == 'qa'
+Requires-Dist: types-setuptools (==67.2.0.1) ; extra == 'qa'
+Provides-Extra: testing
+Requires-Dist: docopt ; extra == 'testing'
+Requires-Dist: pytest ; extra == 'testing'
+
+###################################################################
+parso - A Python Parser
+###################################################################
+
+
+.. image:: https://github.com/davidhalter/parso/workflows/Build/badge.svg?branch=master
+    :target: https://github.com/davidhalter/parso/actions
+    :alt: GitHub Actions build status
+
+.. image:: https://coveralls.io/repos/github/davidhalter/parso/badge.svg?branch=master
+    :target: https://coveralls.io/github/davidhalter/parso?branch=master
+    :alt: Coverage Status
+
+.. image:: https://pepy.tech/badge/parso
+    :target: https://pepy.tech/project/parso
+    :alt: PyPI Downloads
+
+.. image:: https://raw.githubusercontent.com/davidhalter/parso/master/docs/_static/logo_characters.png
+
+Parso is a Python parser that supports error recovery and round-trip parsing
+for different Python versions (in multiple Python versions). Parso is also able
+to list multiple syntax errors in your python file.
+
+Parso has been battle-tested by jedi_. It was pulled out of jedi to be useful
+for other projects as well.
+
+Parso consists of a small API to parse Python and analyse the syntax tree.
+
+A simple example:
+
+.. code-block:: python
+
+    >>> import parso
+    >>> module = parso.parse('hello + 1', version="3.9")
+    >>> expr = module.children[0]
+    >>> expr
+    PythonNode(arith_expr, [<Name: hello@1,0>, <Operator: +>, <Number: 1>])
+    >>> print(expr.get_code())
+    hello + 1
+    >>> name = expr.children[0]
+    >>> name
+    <Name: hello@1,0>
+    >>> name.end_pos
+    (1, 5)
+    >>> expr.end_pos
+    (1, 9)
+
+To list multiple issues:
+
+.. code-block:: python
+
+    >>> grammar = parso.load_grammar()
+    >>> module = grammar.parse('foo +\nbar\ncontinue')
+    >>> error1, error2 = grammar.iter_errors(module)
+    >>> error1.message
+    'SyntaxError: invalid syntax'
+    >>> error2.message
+    "SyntaxError: 'continue' not properly in loop"
+
+Resources
+=========
+
+- `Testing <https://parso.readthedocs.io/en/latest/docs/development.html#testing>`_
+- `PyPI <https://pypi.python.org/pypi/parso>`_
+- `Docs <https://parso.readthedocs.org/en/latest/>`_
+- Uses `semantic versioning <https://semver.org/>`_
+
+Installation
+============
+
+    pip install parso
+
+Future
+======
+
+- There will be better support for refactoring and comments. Stay tuned.
+- There's a WIP PEP8 validator. It's however not in a good shape, yet.
+
+Known Issues
+============
+
+- `async`/`await` are already used as keywords in Python3.6.
+- `from __future__ import print_function` is not ignored.
+
+
+Acknowledgements
+================
+
+- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2
+  (originally used in lib2to3).
+- `Salome Schneider <https://www.crepes-schnaegg.ch/cr%C3%AApes-schn%C3%A4gg/kunst-f%C3%BCrs-cr%C3%AApes-mobil/>`_
+  for the extremely awesome parso logo.
+
+
+.. _jedi: https://github.com/davidhalter/jedi
+
+
+.. :changelog:
+
+Changelog
+---------
+
+Unreleased
+++++++++++
+
+0.8.4 (2024-04-05)
+++++++++++++++++++
+
+- Add basic support for Python 3.13
+
+0.8.3 (2021-11-30)
+++++++++++++++++++
+
+- Add basic support for Python 3.11 and 3.12
+
+0.8.2 (2021-03-30)
+++++++++++++++++++
+
+- Various small bugfixes
+
+0.8.1 (2020-12-10)
+++++++++++++++++++
+
+- Various small bugfixes
+
+0.8.0 (2020-08-05)
+++++++++++++++++++
+
+- Dropped Support for Python 2.7, 3.4, 3.5
+- It's possible to use ``pathlib.Path`` objects now in the API
+- The stubs are gone, we are now using annotations
+- ``namedexpr_test`` nodes are now a proper class called ``NamedExpr``
+- A lot of smaller refactorings
+
+0.7.1 (2020-07-24)
+++++++++++++++++++
+
+- Fixed a couple of smaller bugs (mostly syntax error detection in
+  ``Grammar.iter_errors``)
+
+This is going to be the last release that supports Python 2.7, 3.4 and 3.5.
+
+0.7.0 (2020-04-13)
+++++++++++++++++++
+
+- Fix a lot of annoying bugs in the diff parser. The fuzzer did not find
+  issues anymore even after running it for more than 24 hours (500k tests).
+- Small grammar change: suites can now contain newlines even after a newline.
+  This should really not matter if you don't use error recovery. It allows for
+  nicer error recovery.
+
+0.6.2 (2020-02-27)
+++++++++++++++++++
+
+- Bugfixes
+- Add Grammar.refactor (might still be subject to change until 0.7.0)
+
+0.6.1 (2020-02-03)
+++++++++++++++++++
+
+- Add ``parso.normalizer.Issue.end_pos`` to make it possible to know where an
+  issue ends
+
+0.6.0 (2020-01-26)
+++++++++++++++++++
+
+- Dropped Python 2.6/Python 3.3 support
+- del_stmt names are now considered as a definition
+  (for ``name.is_definition()``)
+- Bugfixes
+
+0.5.2 (2019-12-15)
+++++++++++++++++++
+
+- Add include_setitem to get_definition/is_definition and get_defined_names (#66)
+- Fix named expression error listing (#89, #90)
+- Fix some f-string tokenizer issues (#93)
+
+0.5.1 (2019-07-13)
+++++++++++++++++++
+
+- Fix: Some unicode identifiers were not correctly tokenized
+- Fix: Line continuations in f-strings are now working
+
+0.5.0 (2019-06-20)
+++++++++++++++++++
+
+- **Breaking Change** comp_for is now called sync_comp_for for all Python
+  versions to be compatible with the Python 3.8 Grammar
+- Added .pyi stubs for a lot of the parso API
+- Small FileIO changes
+
+0.4.0 (2019-04-05)
+++++++++++++++++++
+
+- Python 3.8 support
+- FileIO support, it's now possible to use abstract file IO, support is alpha
+
+0.3.4 (2019-02-13)
++++++++++++++++++++
+
+- Fix an f-string tokenizer error
+
+0.3.3 (2019-02-06)
++++++++++++++++++++
+
+- Fix async errors in the diff parser
+- A fix in iter_errors
+- This is a very small bugfix release
+
+0.3.2 (2019-01-24)
++++++++++++++++++++
+
+- 20+ bugfixes in the diff parser and 3 in the tokenizer
+- A fuzzer for the diff parser, to give confidence that the diff parser is in a
+  good shape.
+- Some bugfixes for f-string
+
+0.3.1 (2018-07-09)
++++++++++++++++++++
+
+- Bugfixes in the diff parser and keyword-only arguments
+
+0.3.0 (2018-06-30)
++++++++++++++++++++
+
+- Rewrote the pgen2 parser generator.
+
+0.2.1 (2018-05-21)
++++++++++++++++++++
+
+- A bugfix for the diff parser.
+- Grammar files can now be loaded from a specific path.
+
+0.2.0 (2018-04-15)
++++++++++++++++++++
+
+- f-strings are now parsed as a part of the normal Python grammar. This makes
+  it way easier to deal with them.
+
+0.1.1 (2017-11-05)
++++++++++++++++++++
+
+- Fixed a few bugs in the caching layer
+- Added support for Python 3.7
+
+0.1.0 (2017-09-04)
++++++++++++++++++++
+
+- Pulling the library out of Jedi. Some APIs will definitely change.
+
+

evalkit_tf446/lib/python3.10/site-packages/parso-0.8.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+parso

evalkit_tf446/lib/python3.10/site-packages/uvicorn-0.32.0.dist-info/RECORD

@@ -0,0 +1,87 @@
+../../../bin/uvicorn,sha256=iYbzwXo_ZbjDjrDc6eif7iIHRKhJB2a2m4lH5s8ZcYk,230
+uvicorn-0.32.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+uvicorn-0.32.0.dist-info/METADATA,sha256=uM66dN5rYhRB3gOPuEfEVITkmMNPGXNNX5V5b2mkgXw,6620
+uvicorn-0.32.0.dist-info/RECORD,,
+uvicorn-0.32.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn-0.32.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+uvicorn-0.32.0.dist-info/entry_points.txt,sha256=FW1w-hkc9QgwaGoovMvm0ZY73w_NcycWdGAUfDsNGxw,46
+uvicorn-0.32.0.dist-info/licenses/LICENSE.md,sha256=7-Gs8-YvuZwoiw7HPlp3O3Jo70Mg_nV-qZQhTktjw3E,1526
+uvicorn/__init__.py,sha256=WepnRLFNoKFn9CYP5C2Ya8jtfACAx_r-T_E5yIIQU6Q,147
+uvicorn/__main__.py,sha256=DQizy6nKP0ywhPpnCHgmRDYIMfcqZKVEzNIWQZjqtVQ,62
+uvicorn/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/__pycache__/__main__.cpython-310.pyc,,
+uvicorn/__pycache__/_subprocess.cpython-310.pyc,,
+uvicorn/__pycache__/_types.cpython-310.pyc,,
+uvicorn/__pycache__/config.cpython-310.pyc,,
+uvicorn/__pycache__/importer.cpython-310.pyc,,
+uvicorn/__pycache__/logging.cpython-310.pyc,,
+uvicorn/__pycache__/main.cpython-310.pyc,,
+uvicorn/__pycache__/server.cpython-310.pyc,,
+uvicorn/__pycache__/workers.cpython-310.pyc,,
+uvicorn/_subprocess.py,sha256=HbfRnsCkXyg7xCWVAWWzXQTeWlvLKfTlIF5wevFBkR4,2766
+uvicorn/_types.py,sha256=TcUzCyKNq90ZX2Hxa6ce0juF558zLO_AyBB1XijnD2Y,7814
+uvicorn/config.py,sha256=gpsukzuJFbXBRN5_qOnLGiENmGgKM0Fi-eZJ6GwM1dQ,20849
+uvicorn/importer.py,sha256=nRt0QQ3qpi264-n_mR0l55C2ddM8nowTNzT1jsWaam8,1128
+uvicorn/lifespan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/lifespan/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/lifespan/__pycache__/off.cpython-310.pyc,,
+uvicorn/lifespan/__pycache__/on.cpython-310.pyc,,
+uvicorn/lifespan/off.py,sha256=nfI6qHAUo_8-BEXMBKoHQ9wUbsXrPaXLCbDSS0vKSr8,332
+uvicorn/lifespan/on.py,sha256=1KYuFNNyQONIjtEHhKZAJp-OOokIyjj74wpGCGBv4lk,5184
+uvicorn/logging.py,sha256=sg4D9lHaW_kKQj_kmP-bolbChjKfhBuihktlWp8RjSI,4236
+uvicorn/loops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/loops/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/loops/__pycache__/asyncio.cpython-310.pyc,,
+uvicorn/loops/__pycache__/auto.cpython-310.pyc,,
+uvicorn/loops/__pycache__/uvloop.cpython-310.pyc,,
+uvicorn/loops/asyncio.py,sha256=qPnQLT2htZkcGG_ncnTyrSH38jEkqjg8guwP0lA146A,301
+uvicorn/loops/auto.py,sha256=BWVq18ce9SoFTo3z5zNW2IU2850u2tRrc6WyK7idsdI,400
+uvicorn/loops/uvloop.py,sha256=K4QybYVxtK9C2emDhDPUCkBXR4XMT5Ofv9BPFPoX0ok,148
+uvicorn/main.py,sha256=iv6ptgDBnko0W-VkHs0e3I4UrF7_5sEZrntQNKJGFNY,16915
+uvicorn/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/middleware/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/middleware/__pycache__/asgi2.cpython-310.pyc,,
+uvicorn/middleware/__pycache__/message_logger.cpython-310.pyc,,
+uvicorn/middleware/__pycache__/proxy_headers.cpython-310.pyc,,
+uvicorn/middleware/__pycache__/wsgi.cpython-310.pyc,,
+uvicorn/middleware/asgi2.py,sha256=YQrQNm3RehFts3mzk3k4yw8aD8Egtj0tRS3N45YkQa0,394
+uvicorn/middleware/message_logger.py,sha256=IHEZUSnFNaMFUFdwtZO3AuFATnYcSor-gVtOjbCzt8M,2859
+uvicorn/middleware/proxy_headers.py,sha256=f1VDAc-ipPHdNTuLNHwYCeDgYXoCL_VjD6hDTUXZT_U,5790
+uvicorn/middleware/wsgi.py,sha256=TBeG4W_gEmWddbGfWyxdzJ0IDaWWkJZyF8eIp-1fv0U,7111
+uvicorn/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/protocols/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/protocols/__pycache__/utils.cpython-310.pyc,,
+uvicorn/protocols/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/protocols/http/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/protocols/http/__pycache__/auto.cpython-310.pyc,,
+uvicorn/protocols/http/__pycache__/flow_control.cpython-310.pyc,,
+uvicorn/protocols/http/__pycache__/h11_impl.cpython-310.pyc,,
+uvicorn/protocols/http/__pycache__/httptools_impl.cpython-310.pyc,,
+uvicorn/protocols/http/auto.py,sha256=YfXGyzWTaaE2p_jkTPWrJCXsxEaQnC3NK0-G7Wgmnls,403
+uvicorn/protocols/http/flow_control.py,sha256=050WVg31EvPOkHwynCoMP1zXFl_vO3U4durlc5vyp4U,1701
+uvicorn/protocols/http/h11_impl.py,sha256=MuX72-pIyZGHDtZ75-1mveeTj6_ruL-306Ug7z0yV8w,20765
+uvicorn/protocols/http/httptools_impl.py,sha256=TikbbIZRFG08KTClZER47ehM1Tu8koBfT6WGU5t5ACg,21491
+uvicorn/protocols/utils.py,sha256=rCjYLd4_uwPeZkbRXQ6beCfxyI_oYpvJCwz3jEGNOiE,1849
+uvicorn/protocols/websockets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uvicorn/protocols/websockets/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/protocols/websockets/__pycache__/auto.cpython-310.pyc,,
+uvicorn/protocols/websockets/__pycache__/websockets_impl.cpython-310.pyc,,
+uvicorn/protocols/websockets/__pycache__/wsproto_impl.cpython-310.pyc,,
+uvicorn/protocols/websockets/auto.py,sha256=kNP-h07ZzjA9dKRUd7MNO0J7xhRJ5xVBfit7wCbdB0A,574
+uvicorn/protocols/websockets/websockets_impl.py,sha256=LV58OW3whQAd4iwbJl4R3iIod8myVYK3IhAn6F5VeZ4,15490
+uvicorn/protocols/websockets/wsproto_impl.py,sha256=haJEXK82Ldu8_hz4NDxQ0KpPXa9vOi6pG6iDLoBDKjs,15341
+uvicorn/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+uvicorn/server.py,sha256=McDmVn0sBIVOzaCoKrp10oxaScD3tosoWhtsL1YldNo,13010
+uvicorn/supervisors/__init__.py,sha256=UVJYW3RVHMDSgUytToyAgGyd9NUQVqbNpVrQrvm4Tpc,700
+uvicorn/supervisors/__pycache__/__init__.cpython-310.pyc,,
+uvicorn/supervisors/__pycache__/basereload.cpython-310.pyc,,
+uvicorn/supervisors/__pycache__/multiprocess.cpython-310.pyc,,
+uvicorn/supervisors/__pycache__/statreload.cpython-310.pyc,,
+uvicorn/supervisors/__pycache__/watchfilesreload.cpython-310.pyc,,
+uvicorn/supervisors/__pycache__/watchgodreload.cpython-310.pyc,,
+uvicorn/supervisors/basereload.py,sha256=Hxezjgt_HXkOPVj-hJGH7uj0bZ3EhmwsmaOBc63ySoM,3831
+uvicorn/supervisors/multiprocess.py,sha256=Opt0XvOUj1DIMXYwb4OlkJZxeh_RjweFnTmDPYItONw,7507
+uvicorn/supervisors/statreload.py,sha256=gc-HUB44f811PvxD_ZIEQYenM7mWmhQQjYg7KKQ1c5o,1542
+uvicorn/supervisors/watchfilesreload.py,sha256=41FGNMXPKrKvPr-5O8yRWg43l6OCBtapt39M-gpdk0E,3010
+uvicorn/supervisors/watchgodreload.py,sha256=kd-gOvp14ArTNIc206Nt5CEjZZ4NP2UmMVYE7571yRQ,5486
+uvicorn/workers.py,sha256=DukTKlrCyyvWVHbJWBJflIV2yUe-q6KaGdrEwLrNmyc,3893

evalkit_tf446/lib/python3.10/site-packages/uvicorn-0.32.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+uvicorn = uvicorn.main:main

evalkit_tf446/lib/python3.10/site-packages/uvicorn-0.32.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,27 @@
+Copyright © 2017-present, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.