Add files using upload-large-folder tool

.gitattributes

@@ -537,3 +537,6 @@ janus/lib/python3.10/site-packages/numpy/random/_common.cpython-310-x86_64-linux
 evalkit_cambrian/lib/python3.10/site-packages/google/cloud/storage/__pycache__/bucket.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/lib2to3/tests/__pycache__/test_fixers.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_cambrian/lib/python3.10/site-packages/opencv_python.libs/libavformat-d296e685.so.59.27.100 filter=lfs diff=lfs merge=lfs -text
+falcon/lib/python3.10/site-packages/pillow.libs/libtiff-a92b430c.so.6.0.2 filter=lfs diff=lfs merge=lfs -text
+evalkit_cambrian/lib/python3.10/site-packages/scipy/special/_ufuncs_cxx.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+evalkit_tf437/lib/libtcl8.6.so filter=lfs diff=lfs merge=lfs -text

evalkit_cambrian/lib/python3.10/site-packages/scipy/special/_ufuncs_cxx.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94b3381d0a7eb849854e36036eaa73225ac3ba9c23f9b776ecc84560f4df8fd0
+size 1854728

evalkit_tf437/lib/libtcl8.6.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93e108c5abb9c4b9bd0a256743fe8a22ecdd9f4a4740bf6182a6afe1ecaaf112
+size 1983416

evalkit_tf437/lib/python3.10/site-packages/ftfy/chardata.py

@@ -0,0 +1,691 @@
+"""
+This gives other modules access to the gritty details about characters and the
+encodings that use them.
+"""
+
+from __future__ import annotations
+
+import html
+import itertools
+import re
+import unicodedata
+
+# These are the encodings we will try to fix in ftfy, in the
+# order that they should be tried.
+CHARMAP_ENCODINGS = [
+    "latin-1",
+    "sloppy-windows-1252",
+    "sloppy-windows-1251",
+    "sloppy-windows-1250",
+    "sloppy-windows-1253",
+    "sloppy-windows-1254",
+    "sloppy-windows-1257",
+    "iso-8859-2",
+    "macroman",
+    "cp437",
+]
+
+SINGLE_QUOTE_RE = re.compile("[\u02bc\u2018-\u201b]")
+DOUBLE_QUOTE_RE = re.compile("[\u201c-\u201f]")
+
+
+def _build_regexes() -> dict[str, re.Pattern[str]]:
+    """
+    ENCODING_REGEXES contain reasonably fast ways to detect if we
+    could represent a given string in a given encoding. The simplest one is
+    the 'ascii' detector, which of course just determines if all characters
+    are between U+0000 and U+007F.
+    """
+    # Define a regex that matches ASCII text.
+    encoding_regexes = {"ascii": re.compile("^[\x00-\x7f]*$")}
+
+    for encoding in CHARMAP_ENCODINGS:
+        # Make a sequence of characters that bytes \x80 to \xFF decode to
+        # in each encoding, as well as byte \x1A, which is used to represent
+        # the replacement character � in the sloppy-* encodings.
+        byte_range = bytes(list(range(0x80, 0x100)) + [0x1A])
+        charlist = byte_range.decode(encoding)
+
+        # The rest of the ASCII bytes -- bytes \x00 to \x19 and \x1B
+        # to \x7F -- will decode as those ASCII characters in any encoding we
+        # support, so we can just include them as ranges. This also lets us
+        # not worry about escaping regex special characters, because all of
+        # them are in the \x1B to \x7F range.
+        regex = f"^[\x00-\x19\x1b-\x7f{charlist}]*$"
+        encoding_regexes[encoding] = re.compile(regex)
+    return encoding_regexes
+
+
+ENCODING_REGEXES = _build_regexes()
+
+
+def _build_html_entities() -> dict[str, str]:
+    entities = {}
+    # Create a dictionary based on the built-in HTML5 entity dictionary.
+    # Add a limited set of HTML entities that we'll also decode if they've
+    # been case-folded to uppercase, such as decoding Ñ as "Ñ".
+    for name, char in html.entities.html5.items():  # type: ignore
+        if name.endswith(";"):
+            entities["&" + name] = char
+
+            # Restrict the set of characters we can attempt to decode if their
+            # name has been uppercased. If we tried to handle all entity names,
+            # the results would be ambiguous.
+            if name == name.lower():
+                name_upper = name.upper()
+                entity_upper = "&" + name_upper
+                if html.unescape(entity_upper) == entity_upper:
+                    entities[entity_upper] = char.upper()
+    return entities
+
+
+HTML_ENTITY_RE = re.compile(r"&#?[0-9A-Za-z]{1,24};")
+HTML_ENTITIES = _build_html_entities()
+
+
+def possible_encoding(text: str, encoding: str) -> bool:
+    """
+    Given text and a single-byte encoding, check whether that text could have
+    been decoded from that single-byte encoding.
+
+    In other words, check whether it can be encoded in that encoding, possibly
+    sloppily.
+    """
+    return bool(ENCODING_REGEXES[encoding].match(text))
+
+
+def _build_control_char_mapping() -> dict[int, None]:
+    """
+    Build a translate mapping that strips likely-unintended control characters.
+    See :func:`ftfy.fixes.remove_control_chars` for a description of these
+    codepoint ranges and why they should be removed.
+    """
+    control_chars: dict[int, None] = {}
+
+    for i in itertools.chain(
+        range(0x00, 0x09),
+        [0x0B],
+        range(0x0E, 0x20),
+        [0x7F],
+        range(0x206A, 0x2070),
+        [0xFEFF],
+        range(0xFFF9, 0xFFFD),
+    ):
+        control_chars[i] = None
+
+    return control_chars
+
+
+CONTROL_CHARS = _build_control_char_mapping()
+
+
+# Recognize UTF-8 sequences that would be valid if it weren't for a b'\xa0'
+# that some Windows-1252 program converted to a plain space.
+#
+# The smaller values are included on a case-by-case basis, because we don't want
+# to decode likely input sequences to unlikely characters. These are the ones
+# that *do* form likely characters before 0xa0:
+#
+#   0xc2 -> U+A0 NO-BREAK SPACE
+#   0xc3 -> U+E0 LATIN SMALL LETTER A WITH GRAVE
+#   0xc5 -> U+160 LATIN CAPITAL LETTER S WITH CARON
+#   0xce -> U+3A0 GREEK CAPITAL LETTER PI
+#   0xd0 -> U+420 CYRILLIC CAPITAL LETTER ER
+#   0xd9 -> U+660 ARABIC-INDIC DIGIT ZERO
+#
+# In three-character sequences, we exclude some lead bytes in some cases.
+#
+# When the lead byte is immediately followed by 0xA0, we shouldn't accept
+# a space there, because it leads to some less-likely character ranges:
+#
+#   0xe0 -> Samaritan script
+#   0xe1 -> Mongolian script (corresponds to Latin-1 'á' which is too common)
+#
+# We accept 0xe2 and 0xe3, which cover many scripts. Bytes 0xe4 and
+# higher point mostly to CJK characters, which we generally don't want to
+# decode near Latin lowercase letters.
+#
+# In four-character sequences, the lead byte must be F0, because that accounts
+# for almost all of the usage of high-numbered codepoints (tag characters whose
+# UTF-8 starts with the byte F3 are only used in some rare new emoji sequences).
+#
+# This is meant to be applied to encodings of text that tests true for `is_bad`.
+# Any of these could represent characters that legitimately appear surrounded by
+# spaces, particularly U+C5 (Å), which is a word in multiple languages!
+#
+# We should consider checking for b'\x85' being converted to ... in the future.
+# I've seen it once, but the text still wasn't recoverable.
+
+ALTERED_UTF8_RE = re.compile(
+    b"[\xc2\xc3\xc5\xce\xd0\xd9][ ]"
+    b"|[\xe2\xe3][ ][\x80-\x84\x86-\x9f\xa1-\xbf]"
+    b"|[\xe0-\xe3][\x80-\x84\x86-\x9f\xa1-\xbf][ ]"
+    b"|[\xf0][ ][\x80-\xbf][\x80-\xbf]"
+    b"|[\xf0][\x80-\xbf][ ][\x80-\xbf]"
+    b"|[\xf0][\x80-\xbf][\x80-\xbf][ ]"
+)
+
+
+# This expression matches UTF-8 and CESU-8 sequences where some of the
+# continuation bytes have been lost. The byte 0x1a (sometimes written as ^Z) is
+# used within ftfy to represent a byte that produced the replacement character
+# \ufffd. We don't know which byte it was, but we can at least decode the UTF-8
+# sequence as \ufffd instead of failing to re-decode it at all.
+#
+# In some cases, we allow the ASCII '?' in place of \ufffd, but at most once per
+# sequence.
+LOSSY_UTF8_RE = re.compile(
+    b"[\xc2-\xdf][\x1a]"
+    b"|[\xc2-\xc3][?]"
+    b"|\xed[\xa0-\xaf][\x1a?]\xed[\xb0-\xbf][\x1a?\x80-\xbf]"
+    b"|\xed[\xa0-\xaf][\x1a?\x80-\xbf]\xed[\xb0-\xbf][\x1a?]"
+    b"|[\xe0-\xef][\x1a?][\x1a\x80-\xbf]"
+    b"|[\xe0-\xef][\x1a\x80-\xbf][\x1a?]"
+    b"|[\xf0-\xf4][\x1a?][\x1a\x80-\xbf][\x1a\x80-\xbf]"
+    b"|[\xf0-\xf4][\x1a\x80-\xbf][\x1a?][\x1a\x80-\xbf]"
+    b"|[\xf0-\xf4][\x1a\x80-\xbf][\x1a\x80-\xbf][\x1a?]"
+    b"|\x1a"
+)
+
+
+# This regex matches C1 control characters, which occupy some of the positions
+# in the Latin-1 character map that Windows assigns to other characters instead.
+C1_CONTROL_RE = re.compile(r"[\x80-\x9f]")
+
+
+# A translate mapping that breaks ligatures made of Latin letters. While
+# ligatures may be important to the representation of other languages, in Latin
+# letters they tend to represent a copy/paste error. It omits ligatures such
+# as æ that are frequently used intentionally.
+#
+# This list additionally includes some Latin digraphs that represent two
+# characters for legacy encoding reasons, not for typographical reasons.
+#
+# Ligatures and digraphs may also be separated by NFKC normalization, but that
+# is sometimes more normalization than you want.
+
+LIGATURES = {
+    ord("IJ"): "IJ",  # Dutch ligatures
+    ord("ij"): "ij",
+    ord("ʼn"): "ʼn",  # Afrikaans digraph meant to avoid auto-curled quote
+    ord("DZ"): "DZ",  # Serbian/Croatian digraphs for Cyrillic conversion
+    ord("Dz"): "Dz",
+    ord("dz"): "dz",
+    ord("DŽ"): "DŽ",
+    ord("Dž"): "Dž",
+    ord("dž"): "dž",
+    ord("LJ"): "LJ",
+    ord("Lj"): "Lj",
+    ord("lj"): "lj",
+    ord("NJ"): "NJ",
+    ord("Nj"): "Nj",
+    ord("nj"): "nj",
+    ord("ff"): "ff",  # Latin typographical ligatures
+    ord("fi"): "fi",
+    ord("fl"): "fl",
+    ord("ffi"): "ffi",
+    ord("ffl"): "ffl",
+    ord("ſt"): "ſt",
+    ord("st"): "st",
+}
+
+
+def _build_width_map() -> dict[int, str]:
+    """
+    Build a translate mapping that replaces halfwidth and fullwidth forms
+    with their standard-width forms.
+    """
+    # Though it's not listed as a fullwidth character, we'll want to convert
+    # U+3000 IDEOGRAPHIC SPACE to U+20 SPACE on the same principle, so start
+    # with that in the dictionary.
+    width_map = {0x3000: " "}
+    for i in range(0xFF01, 0xFFF0):
+        char = chr(i)
+        alternate = unicodedata.normalize("NFKC", char)
+        if alternate != char:
+            width_map[i] = alternate
+    return width_map
+
+
+WIDTH_MAP = _build_width_map()
+
+
+# Character classes that help us pinpoint embedded mojibake. These can
+# include common characters, because we'll also check them for 'badness'.
+#
+# Though they go on for many lines, the members of this dictionary are
+# single concatenated strings.
+#
+# This code is generated using scripts/char_data_table.py.
+UTF8_CLUES: dict[str, str] = {
+    # Letters that decode to 0xC2 - 0xDF in a Latin-1-like encoding
+    "utf8_first_of_2": (
+        "\N{LATIN CAPITAL LETTER A WITH BREVE}"  # windows-1250:C3
+        "\N{LATIN CAPITAL LETTER A WITH CIRCUMFLEX}"  # latin-1:C2
+        "\N{LATIN CAPITAL LETTER A WITH DIAERESIS}"  # latin-1:C4
+        "\N{LATIN CAPITAL LETTER A WITH MACRON}"  # windows-1257:C2
+        "\N{LATIN CAPITAL LETTER A WITH RING ABOVE}"  # latin-1:C5
+        "\N{LATIN CAPITAL LETTER A WITH TILDE}"  # latin-1:C3
+        "\N{LATIN CAPITAL LETTER AE}"  # latin-1:C6
+        "\N{LATIN CAPITAL LETTER C WITH ACUTE}"  # windows-1250:C6
+        "\N{LATIN CAPITAL LETTER C WITH CARON}"  # windows-1250:C8
+        "\N{LATIN CAPITAL LETTER C WITH CEDILLA}"  # latin-1:C7
+        "\N{LATIN CAPITAL LETTER D WITH CARON}"  # windows-1250:CF
+        "\N{LATIN CAPITAL LETTER D WITH STROKE}"  # windows-1250:D0
+        "\N{LATIN CAPITAL LETTER E WITH ACUTE}"  # latin-1:C9
+        "\N{LATIN CAPITAL LETTER E WITH CARON}"  # windows-1250:CC
+        "\N{LATIN CAPITAL LETTER E WITH CIRCUMFLEX}"  # latin-1:CA
+        "\N{LATIN CAPITAL LETTER E WITH DIAERESIS}"  # latin-1:CB
+        "\N{LATIN CAPITAL LETTER E WITH DOT ABOVE}"  # windows-1257:CB
+        "\N{LATIN CAPITAL LETTER E WITH GRAVE}"  # latin-1:C8
+        "\N{LATIN CAPITAL LETTER E WITH MACRON}"  # windows-1257:C7
+        "\N{LATIN CAPITAL LETTER E WITH OGONEK}"  # windows-1250:CA
+        "\N{LATIN CAPITAL LETTER ETH}"  # latin-1:D0
+        "\N{LATIN CAPITAL LETTER G WITH BREVE}"  # windows-1254:D0
+        "\N{LATIN CAPITAL LETTER G WITH CEDILLA}"  # windows-1257:CC
+        "\N{LATIN CAPITAL LETTER I WITH ACUTE}"  # latin-1:CD
+        "\N{LATIN CAPITAL LETTER I WITH CIRCUMFLEX}"  # latin-1:CE
+        "\N{LATIN CAPITAL LETTER I WITH DIAERESIS}"  # latin-1:CF
+        "\N{LATIN CAPITAL LETTER I WITH DOT ABOVE}"  # windows-1254:DD
+        "\N{LATIN CAPITAL LETTER I WITH GRAVE}"  # latin-1:CC
+        "\N{LATIN CAPITAL LETTER I WITH MACRON}"  # windows-1257:CE
+        "\N{LATIN CAPITAL LETTER K WITH CEDILLA}"  # windows-1257:CD
+        "\N{LATIN CAPITAL LETTER L WITH ACUTE}"  # windows-1250:C5
+        "\N{LATIN CAPITAL LETTER L WITH CEDILLA}"  # windows-1257:CF
+        "\N{LATIN CAPITAL LETTER L WITH STROKE}"  # windows-1257:D9
+        "\N{LATIN CAPITAL LETTER N WITH ACUTE}"  # windows-1250:D1
+        "\N{LATIN CAPITAL LETTER N WITH CARON}"  # windows-1250:D2
+        "\N{LATIN CAPITAL LETTER N WITH CEDILLA}"  # windows-1257:D2
+        "\N{LATIN CAPITAL LETTER N WITH TILDE}"  # latin-1:D1
+        "\N{LATIN CAPITAL LETTER O WITH ACUTE}"  # latin-1:D3
+        "\N{LATIN CAPITAL LETTER O WITH CIRCUMFLEX}"  # latin-1:D4
+        "\N{LATIN CAPITAL LETTER O WITH DIAERESIS}"  # latin-1:D6
+        "\N{LATIN CAPITAL LETTER O WITH DOUBLE ACUTE}"  # windows-1250:D5
+        "\N{LATIN CAPITAL LETTER O WITH GRAVE}"  # latin-1:D2
+        "\N{LATIN CAPITAL LETTER O WITH MACRON}"  # windows-1257:D4
+        "\N{LATIN CAPITAL LETTER O WITH STROKE}"  # latin-1:D8
+        "\N{LATIN CAPITAL LETTER O WITH TILDE}"  # latin-1:D5
+        "\N{LATIN CAPITAL LETTER R WITH CARON}"  # windows-1250:D8
+        "\N{LATIN CAPITAL LETTER S WITH ACUTE}"  # windows-1257:DA
+        "\N{LATIN CAPITAL LETTER S WITH CARON}"  # windows-1257:D0
+        "\N{LATIN CAPITAL LETTER S WITH CEDILLA}"  # windows-1254:DE
+        "\N{LATIN CAPITAL LETTER T WITH CEDILLA}"  # windows-1250:DE
+        "\N{LATIN CAPITAL LETTER THORN}"  # latin-1:DE
+        "\N{LATIN CAPITAL LETTER U WITH ACUTE}"  # latin-1:DA
+        "\N{LATIN CAPITAL LETTER U WITH CIRCUMFLEX}"  # latin-1:DB
+        "\N{LATIN CAPITAL LETTER U WITH DIAERESIS}"  # latin-1:DC
+        "\N{LATIN CAPITAL LETTER U WITH DOUBLE ACUTE}"  # windows-1250:DB
+        "\N{LATIN CAPITAL LETTER U WITH GRAVE}"  # latin-1:D9
+        "\N{LATIN CAPITAL LETTER U WITH MACRON}"  # windows-1257:DB
+        "\N{LATIN CAPITAL LETTER U WITH OGONEK}"  # windows-1257:D8
+        "\N{LATIN CAPITAL LETTER U WITH RING ABOVE}"  # windows-1250:D9
+        "\N{LATIN CAPITAL LETTER Y WITH ACUTE}"  # latin-1:DD
+        "\N{LATIN CAPITAL LETTER Z WITH ACUTE}"  # windows-1257:CA
+        "\N{LATIN CAPITAL LETTER Z WITH CARON}"  # windows-1257:DE
+        "\N{LATIN CAPITAL LETTER Z WITH DOT ABOVE}"  # windows-1257:DD
+        "\N{LATIN SMALL LETTER SHARP S}"  # latin-1:DF
+        "\N{MULTIPLICATION SIGN}"  # latin-1:D7
+        "\N{GREEK CAPITAL LETTER BETA}"  # windows-1253:C2
+        "\N{GREEK CAPITAL LETTER GAMMA}"  # windows-1253:C3
+        "\N{GREEK CAPITAL LETTER DELTA}"  # windows-1253:C4
+        "\N{GREEK CAPITAL LETTER EPSILON}"  # windows-1253:C5
+        "\N{GREEK CAPITAL LETTER ZETA}"  # windows-1253:C6
+        "\N{GREEK CAPITAL LETTER ETA}"  # windows-1253:C7
+        "\N{GREEK CAPITAL LETTER THETA}"  # windows-1253:C8
+        "\N{GREEK CAPITAL LETTER IOTA}"  # windows-1253:C9
+        "\N{GREEK CAPITAL LETTER KAPPA}"  # windows-1253:CA
+        "\N{GREEK CAPITAL LETTER LAMDA}"  # windows-1253:CB
+        "\N{GREEK CAPITAL LETTER MU}"  # windows-1253:CC
+        "\N{GREEK CAPITAL LETTER NU}"  # windows-1253:CD
+        "\N{GREEK CAPITAL LETTER XI}"  # windows-1253:CE
+        "\N{GREEK CAPITAL LETTER OMICRON}"  # windows-1253:CF
+        "\N{GREEK CAPITAL LETTER PI}"  # windows-1253:D0
+        "\N{GREEK CAPITAL LETTER RHO}"  # windows-1253:D1
+        "\N{GREEK CAPITAL LETTER SIGMA}"  # windows-1253:D3
+        "\N{GREEK CAPITAL LETTER TAU}"  # windows-1253:D4
+        "\N{GREEK CAPITAL LETTER UPSILON}"  # windows-1253:D5
+        "\N{GREEK CAPITAL LETTER PHI}"  # windows-1253:D6
+        "\N{GREEK CAPITAL LETTER CHI}"  # windows-1253:D7
+        "\N{GREEK CAPITAL LETTER PSI}"  # windows-1253:D8
+        "\N{GREEK CAPITAL LETTER OMEGA}"  # windows-1253:D9
+        "\N{GREEK CAPITAL LETTER IOTA WITH DIALYTIKA}"  # windows-1253:DA
+        "\N{GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA}"  # windows-1253:DB
+        "\N{GREEK SMALL LETTER ALPHA WITH TONOS}"  # windows-1253:DC
+        "\N{GREEK SMALL LETTER EPSILON WITH TONOS}"  # windows-1253:DD
+        "\N{GREEK SMALL LETTER ETA WITH TONOS}"  # windows-1253:DE
+        "\N{GREEK SMALL LETTER IOTA WITH TONOS}"  # windows-1253:DF
+        "\N{CYRILLIC CAPITAL LETTER VE}"  # windows-1251:C2
+        "\N{CYRILLIC CAPITAL LETTER GHE}"  # windows-1251:C3
+        "\N{CYRILLIC CAPITAL LETTER DE}"  # windows-1251:C4
+        "\N{CYRILLIC CAPITAL LETTER IE}"  # windows-1251:C5
+        "\N{CYRILLIC CAPITAL LETTER ZHE}"  # windows-1251:C6
+        "\N{CYRILLIC CAPITAL LETTER ZE}"  # windows-1251:C7
+        "\N{CYRILLIC CAPITAL LETTER I}"  # windows-1251:C8
+        "\N{CYRILLIC CAPITAL LETTER SHORT I}"  # windows-1251:C9
+        "\N{CYRILLIC CAPITAL LETTER KA}"  # windows-1251:CA
+        "\N{CYRILLIC CAPITAL LETTER EL}"  # windows-1251:CB
+        "\N{CYRILLIC CAPITAL LETTER EM}"  # windows-1251:CC
+        "\N{CYRILLIC CAPITAL LETTER EN}"  # windows-1251:CD
+        "\N{CYRILLIC CAPITAL LETTER O}"  # windows-1251:CE
+        "\N{CYRILLIC CAPITAL LETTER PE}"  # windows-1251:CF
+        "\N{CYRILLIC CAPITAL LETTER ER}"  # windows-1251:D0
+        "\N{CYRILLIC CAPITAL LETTER ES}"  # windows-1251:D1
+        "\N{CYRILLIC CAPITAL LETTER TE}"  # windows-1251:D2
+        "\N{CYRILLIC CAPITAL LETTER U}"  # windows-1251:D3
+        "\N{CYRILLIC CAPITAL LETTER EF}"  # windows-1251:D4
+        "\N{CYRILLIC CAPITAL LETTER HA}"  # windows-1251:D5
+        "\N{CYRILLIC CAPITAL LETTER TSE}"  # windows-1251:D6
+        "\N{CYRILLIC CAPITAL LETTER CHE}"  # windows-1251:D7
+        "\N{CYRILLIC CAPITAL LETTER SHA}"  # windows-1251:D8
+        "\N{CYRILLIC CAPITAL LETTER SHCHA}"  # windows-1251:D9
+        "\N{CYRILLIC CAPITAL LETTER HARD SIGN}"  # windows-1251:DA
+        "\N{CYRILLIC CAPITAL LETTER YERU}"  # windows-1251:DB
+        "\N{CYRILLIC CAPITAL LETTER SOFT SIGN}"  # windows-1251:DC
+        "\N{CYRILLIC CAPITAL LETTER E}"  # windows-1251:DD
+        "\N{CYRILLIC CAPITAL LETTER YU}"  # windows-1251:DE
+        "\N{CYRILLIC CAPITAL LETTER YA}"  # windows-1251:DF
+    ),
+    # Letters that decode to 0xE0 - 0xEF in a Latin-1-like encoding
+    "utf8_first_of_3": (
+        "\N{LATIN SMALL LETTER A WITH ACUTE}"  # latin-1:E1
+        "\N{LATIN SMALL LETTER A WITH BREVE}"  # windows-1250:E3
+        "\N{LATIN SMALL LETTER A WITH CIRCUMFLEX}"  # latin-1:E2
+        "\N{LATIN SMALL LETTER A WITH DIAERESIS}"  # latin-1:E4
+        "\N{LATIN SMALL LETTER A WITH GRAVE}"  # latin-1:E0
+        "\N{LATIN SMALL LETTER A WITH MACRON}"  # windows-1257:E2
+        "\N{LATIN SMALL LETTER A WITH OGONEK}"  # windows-1257:E0
+        "\N{LATIN SMALL LETTER A WITH RING ABOVE}"  # latin-1:E5
+        "\N{LATIN SMALL LETTER A WITH TILDE}"  # latin-1:E3
+        "\N{LATIN SMALL LETTER AE}"  # latin-1:E6
+        "\N{LATIN SMALL LETTER C WITH ACUTE}"  # windows-1250:E6
+        "\N{LATIN SMALL LETTER C WITH CARON}"  # windows-1250:E8
+        "\N{LATIN SMALL LETTER C WITH CEDILLA}"  # latin-1:E7
+        "\N{LATIN SMALL LETTER D WITH CARON}"  # windows-1250:EF
+        "\N{LATIN SMALL LETTER E WITH ACUTE}"  # latin-1:E9
+        "\N{LATIN SMALL LETTER E WITH CARON}"  # windows-1250:EC
+        "\N{LATIN SMALL LETTER E WITH CIRCUMFLEX}"  # latin-1:EA
+        "\N{LATIN SMALL LETTER E WITH DIAERESIS}"  # latin-1:EB
+        "\N{LATIN SMALL LETTER E WITH DOT ABOVE}"  # windows-1257:EB
+        "\N{LATIN SMALL LETTER E WITH GRAVE}"  # latin-1:E8
+        "\N{LATIN SMALL LETTER E WITH MACRON}"  # windows-1257:E7
+        "\N{LATIN SMALL LETTER E WITH OGONEK}"  # windows-1250:EA
+        "\N{LATIN SMALL LETTER E WITH OGONEK}"  # windows-1250:EA
+        "\N{LATIN SMALL LETTER G WITH CEDILLA}"  # windows-1257:EC
+        "\N{LATIN SMALL LETTER I WITH ACUTE}"  # latin-1:ED
+        "\N{LATIN SMALL LETTER I WITH CIRCUMFLEX}"  # latin-1:EE
+        "\N{LATIN SMALL LETTER I WITH DIAERESIS}"  # latin-1:EF
+        "\N{LATIN SMALL LETTER I WITH GRAVE}"  # latin-1:EC
+        "\N{LATIN SMALL LETTER I WITH MACRON}"  # windows-1257:EE
+        "\N{LATIN SMALL LETTER I WITH OGONEK}"  # windows-1257:E1
+        "\N{LATIN SMALL LETTER K WITH CEDILLA}"  # windows-1257:ED
+        "\N{LATIN SMALL LETTER L WITH ACUTE}"  # windows-1250:E5
+        "\N{LATIN SMALL LETTER L WITH CEDILLA}"  # windows-1257:EF
+        "\N{LATIN SMALL LETTER R WITH ACUTE}"  # windows-1250:E0
+        "\N{LATIN SMALL LETTER Z WITH ACUTE}"  # windows-1257:EA
+        "\N{GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS}"  # windows-1253:E0
+        "\N{GREEK SMALL LETTER ALPHA}"  # windows-1253:E1
+        "\N{GREEK SMALL LETTER BETA}"  # windows-1253:E2
+        "\N{GREEK SMALL LETTER GAMMA}"  # windows-1253:E3
+        "\N{GREEK SMALL LETTER DELTA}"  # windows-1253:E4
+        "\N{GREEK SMALL LETTER EPSILON}"  # windows-1253:E5
+        "\N{GREEK SMALL LETTER ZETA}"  # windows-1253:E6
+        "\N{GREEK SMALL LETTER ETA}"  # windows-1253:E7
+        "\N{GREEK SMALL LETTER THETA}"  # windows-1253:E8
+        "\N{GREEK SMALL LETTER IOTA}"  # windows-1253:E9
+        "\N{GREEK SMALL LETTER KAPPA}"  # windows-1253:EA
+        "\N{GREEK SMALL LETTER LAMDA}"  # windows-1253:EB
+        "\N{GREEK SMALL LETTER MU}"  # windows-1253:EC
+        "\N{GREEK SMALL LETTER NU}"  # windows-1253:ED
+        "\N{GREEK SMALL LETTER XI}"  # windows-1253:EE
+        "\N{GREEK SMALL LETTER OMICRON}"  # windows-1253:EF
+        "\N{CYRILLIC SMALL LETTER A}"  # windows-1251:E0
+        "\N{CYRILLIC SMALL LETTER BE}"  # windows-1251:E1
+        "\N{CYRILLIC SMALL LETTER VE}"  # windows-1251:E2
+        "\N{CYRILLIC SMALL LETTER GHE}"  # windows-1251:E3
+        "\N{CYRILLIC SMALL LETTER DE}"  # windows-1251:E4
+        "\N{CYRILLIC SMALL LETTER IE}"  # windows-1251:E5
+        "\N{CYRILLIC SMALL LETTER ZHE}"  # windows-1251:E6
+        "\N{CYRILLIC SMALL LETTER ZE}"  # windows-1251:E7
+        "\N{CYRILLIC SMALL LETTER I}"  # windows-1251:E8
+        "\N{CYRILLIC SMALL LETTER SHORT I}"  # windows-1251:E9
+        "\N{CYRILLIC SMALL LETTER KA}"  # windows-1251:EA
+        "\N{CYRILLIC SMALL LETTER EL}"  # windows-1251:EB
+        "\N{CYRILLIC SMALL LETTER EM}"  # windows-1251:EC
+        "\N{CYRILLIC SMALL LETTER EN}"  # windows-1251:ED
+        "\N{CYRILLIC SMALL LETTER O}"  # windows-1251:EE
+        "\N{CYRILLIC SMALL LETTER PE}"  # windows-1251:EF
+    ),
+    # Letters that decode to 0xF0 or 0xF3 in a Latin-1-like encoding.
+    # (Other leading bytes correspond only to unassigned codepoints)
+    "utf8_first_of_4": (
+        "\N{LATIN SMALL LETTER D WITH STROKE}"  # windows-1250:F0
+        "\N{LATIN SMALL LETTER ETH}"  # latin-1:F0
+        "\N{LATIN SMALL LETTER G WITH BREVE}"  # windows-1254:F0
+        "\N{LATIN SMALL LETTER O WITH ACUTE}"  # latin-1:F3
+        "\N{LATIN SMALL LETTER S WITH CARON}"  # windows-1257:F0
+        "\N{GREEK SMALL LETTER PI}"  # windows-1253:F0
+        "\N{GREEK SMALL LETTER SIGMA}"  # windows-1253:F3
+        "\N{CYRILLIC SMALL LETTER ER}"  # windows-1251:F0
+        "\N{CYRILLIC SMALL LETTER U}"  # windows-1251:F3
+    ),
+    # Letters that decode to 0x80 - 0xBF in a Latin-1-like encoding,
+    # including a space standing in for 0xA0
+    "utf8_continuation": (
+        "\x80-\xbf"
+        "\N{SPACE}"  # modification of latin-1:A0, NO-BREAK SPACE
+        "\N{LATIN CAPITAL LETTER A WITH OGONEK}"  # windows-1250:A5
+        "\N{LATIN CAPITAL LETTER AE}"  # windows-1257:AF
+        "\N{LATIN CAPITAL LETTER L WITH CARON}"  # windows-1250:BC
+        "\N{LATIN CAPITAL LETTER L WITH STROKE}"  # windows-1250:A3
+        "\N{LATIN CAPITAL LETTER O WITH STROKE}"  # windows-1257:A8
+        "\N{LATIN CAPITAL LETTER R WITH CEDILLA}"  # windows-1257:AA
+        "\N{LATIN CAPITAL LETTER S WITH ACUTE}"  # windows-1250:8C
+        "\N{LATIN CAPITAL LETTER S WITH CARON}"  # windows-1252:8A
+        "\N{LATIN CAPITAL LETTER S WITH CEDILLA}"  # windows-1250:AA
+        "\N{LATIN CAPITAL LETTER T WITH CARON}"  # windows-1250:8D
+        "\N{LATIN CAPITAL LETTER Y WITH DIAERESIS}"  # windows-1252:9F
+        "\N{LATIN CAPITAL LETTER Z WITH ACUTE}"  # windows-1250:8F
+        "\N{LATIN CAPITAL LETTER Z WITH CARON}"  # windows-1252:8E
+        "\N{LATIN CAPITAL LETTER Z WITH DOT ABOVE}"  # windows-1250:AF
+        "\N{LATIN CAPITAL LIGATURE OE}"  # windows-1252:8C
+        "\N{LATIN SMALL LETTER A WITH OGONEK}"  # windows-1250:B9
+        "\N{LATIN SMALL LETTER AE}"  # windows-1257:BF
+        "\N{LATIN SMALL LETTER F WITH HOOK}"  # windows-1252:83
+        "\N{LATIN SMALL LETTER L WITH CARON}"  # windows-1250:BE
+        "\N{LATIN SMALL LETTER L WITH STROKE}"  # windows-1250:B3
+        "\N{LATIN SMALL LETTER O WITH STROKE}"  # windows-1257:B8
+        "\N{LATIN SMALL LETTER R WITH CEDILLA}"  # windows-1257:BA
+        "\N{LATIN SMALL LETTER S WITH ACUTE}"  # windows-1250:9C
+        "\N{LATIN SMALL LETTER S WITH CARON}"  # windows-1252:9A
+        "\N{LATIN SMALL LETTER S WITH CEDILLA}"  # windows-1250:BA
+        "\N{LATIN SMALL LETTER T WITH CARON}"  # windows-1250:9D
+        "\N{LATIN SMALL LETTER Z WITH ACUTE}"  # windows-1250:9F
+        "\N{LATIN SMALL LETTER Z WITH CARON}"  # windows-1252:9E
+        "\N{LATIN SMALL LETTER Z WITH DOT ABOVE}"  # windows-1250:BF
+        "\N{LATIN SMALL LIGATURE OE}"  # windows-1252:9C
+        "\N{MODIFIER LETTER CIRCUMFLEX ACCENT}"  # windows-1252:88
+        "\N{CARON}"  # windows-1250:A1
+        "\N{BREVE}"  # windows-1250:A2
+        "\N{OGONEK}"  # windows-1250:B2
+        "\N{SMALL TILDE}"  # windows-1252:98
+        "\N{DOUBLE ACUTE ACCENT}"  # windows-1250:BD
+        "\N{GREEK TONOS}"  # windows-1253:B4
+        "\N{GREEK DIALYTIKA TONOS}"  # windows-1253:A1
+        "\N{GREEK CAPITAL LETTER ALPHA WITH TONOS}"  # windows-1253:A2
+        "\N{GREEK CAPITAL LETTER EPSILON WITH TONOS}"  # windows-1253:B8
+        "\N{GREEK CAPITAL LETTER ETA WITH TONOS}"  # windows-1253:B9
+        "\N{GREEK CAPITAL LETTER IOTA WITH TONOS}"  # windows-1253:BA
+        "\N{GREEK CAPITAL LETTER OMICRON WITH TONOS}"  # windows-1253:BC
+        "\N{GREEK CAPITAL LETTER UPSILON WITH TONOS}"  # windows-1253:BE
+        "\N{GREEK CAPITAL LETTER OMEGA WITH TONOS}"  # windows-1253:BF
+        "\N{CYRILLIC CAPITAL LETTER IO}"  # windows-1251:A8
+        "\N{CYRILLIC CAPITAL LETTER DJE}"  # windows-1251:80
+        "\N{CYRILLIC CAPITAL LETTER GJE}"  # windows-1251:81
+        "\N{CYRILLIC CAPITAL LETTER UKRAINIAN IE}"  # windows-1251:AA
+        "\N{CYRILLIC CAPITAL LETTER DZE}"  # windows-1251:BD
+        "\N{CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I}"  # windows-1251:B2
+        "\N{CYRILLIC CAPITAL LETTER YI}"  # windows-1251:AF
+        "\N{CYRILLIC CAPITAL LETTER JE}"  # windows-1251:A3
+        "\N{CYRILLIC CAPITAL LETTER LJE}"  # windows-1251:8A
+        "\N{CYRILLIC CAPITAL LETTER NJE}"  # windows-1251:8C
+        "\N{CYRILLIC CAPITAL LETTER TSHE}"  # windows-1251:8E
+        "\N{CYRILLIC CAPITAL LETTER KJE}"  # windows-1251:8D
+        "\N{CYRILLIC CAPITAL LETTER SHORT U}"  # windows-1251:A1
+        "\N{CYRILLIC CAPITAL LETTER DZHE}"  # windows-1251:8F
+        "\N{CYRILLIC SMALL LETTER IO}"  # windows-1251:B8
+        "\N{CYRILLIC SMALL LETTER DJE}"  # windows-1251:90
+        "\N{CYRILLIC SMALL LETTER GJE}"  # windows-1251:83
+        "\N{CYRILLIC SMALL LETTER UKRAINIAN IE}"  # windows-1251:BA
+        "\N{CYRILLIC SMALL LETTER DZE}"  # windows-1251:BE
+        "\N{CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I}"  # windows-1251:B3
+        "\N{CYRILLIC SMALL LETTER YI}"  # windows-1251:BF
+        "\N{CYRILLIC SMALL LETTER JE}"  # windows-1251:BC
+        "\N{CYRILLIC SMALL LETTER LJE}"  # windows-1251:9A
+        "\N{CYRILLIC SMALL LETTER NJE}"  # windows-1251:9C
+        "\N{CYRILLIC SMALL LETTER TSHE}"  # windows-1251:9E
+        "\N{CYRILLIC SMALL LETTER KJE}"  # windows-1251:9D
+        "\N{CYRILLIC SMALL LETTER SHORT U}"  # windows-1251:A2
+        "\N{CYRILLIC SMALL LETTER DZHE}"  # windows-1251:9F
+        "\N{CYRILLIC CAPITAL LETTER GHE WITH UPTURN}"  # windows-1251:A5
+        "\N{CYRILLIC SMALL LETTER GHE WITH UPTURN}"  # windows-1251:B4
+        "\N{EN DASH}"  # windows-1252:96
+        "\N{EM DASH}"  # windows-1252:97
+        "\N{HORIZONTAL BAR}"  # windows-1253:AF
+        "\N{LEFT SINGLE QUOTATION MARK}"  # windows-1252:91
+        "\N{RIGHT SINGLE QUOTATION MARK}"  # windows-1252:92
+        "\N{SINGLE LOW-9 QUOTATION MARK}"  # windows-1252:82
+        "\N{LEFT DOUBLE QUOTATION MARK}"  # windows-1252:93
+        "\N{RIGHT DOUBLE QUOTATION MARK}"  # windows-1252:94
+        "\N{DOUBLE LOW-9 QUOTATION MARK}"  # windows-1252:84
+        "\N{DAGGER}"  # windows-1252:86
+        "\N{DOUBLE DAGGER}"  # windows-1252:87
+        "\N{BULLET}"  # windows-1252:95
+        "\N{HORIZONTAL ELLIPSIS}"  # windows-1252:85
+        "\N{PER MILLE SIGN}"  # windows-1252:89
+        "\N{SINGLE LEFT-POINTING ANGLE QUOTATION MARK}"  # windows-1252:8B
+        "\N{SINGLE RIGHT-POINTING ANGLE QUOTATION MARK}"  # windows-1252:9B
+        "\N{EURO SIGN}"  # windows-1252:80
+        "\N{NUMERO SIGN}"  # windows-1251:B9
+        "\N{TRADE MARK SIGN}"  # windows-1252:99
+    ),
+    # Letters that decode to 0x80 - 0xBF in a Latin-1-like encoding,
+    # and don't usually stand for themselves when adjacent to mojibake.
+    # This excludes spaces, dashes, 'bullet', quotation marks, and ellipses.
+    "utf8_continuation_strict": (
+        "\x80-\xbf"
+        "\N{LATIN CAPITAL LETTER A WITH OGONEK}"  # windows-1250:A5
+        "\N{LATIN CAPITAL LETTER AE}"  # windows-1257:AF
+        "\N{LATIN CAPITAL LETTER L WITH CARON}"  # windows-1250:BC
+        "\N{LATIN CAPITAL LETTER L WITH STROKE}"  # windows-1250:A3
+        "\N{LATIN CAPITAL LETTER O WITH STROKE}"  # windows-1257:A8
+        "\N{LATIN CAPITAL LETTER R WITH CEDILLA}"  # windows-1257:AA
+        "\N{LATIN CAPITAL LETTER S WITH ACUTE}"  # windows-1250:8C
+        "\N{LATIN CAPITAL LETTER S WITH CARON}"  # windows-1252:8A
+        "\N{LATIN CAPITAL LETTER S WITH CEDILLA}"  # windows-1250:AA
+        "\N{LATIN CAPITAL LETTER T WITH CARON}"  # windows-1250:8D
+        "\N{LATIN CAPITAL LETTER Y WITH DIAERESIS}"  # windows-1252:9F
+        "\N{LATIN CAPITAL LETTER Z WITH ACUTE}"  # windows-1250:8F
+        "\N{LATIN CAPITAL LETTER Z WITH CARON}"  # windows-1252:8E
+        "\N{LATIN CAPITAL LETTER Z WITH DOT ABOVE}"  # windows-1250:AF
+        "\N{LATIN CAPITAL LIGATURE OE}"  # windows-1252:8C
+        "\N{LATIN SMALL LETTER A WITH OGONEK}"  # windows-1250:B9
+        "\N{LATIN SMALL LETTER AE}"  # windows-1257:BF
+        "\N{LATIN SMALL LETTER F WITH HOOK}"  # windows-1252:83
+        "\N{LATIN SMALL LETTER L WITH CARON}"  # windows-1250:BE
+        "\N{LATIN SMALL LETTER L WITH STROKE}"  # windows-1250:B3
+        "\N{LATIN SMALL LETTER O WITH STROKE}"  # windows-1257:B8
+        "\N{LATIN SMALL LETTER R WITH CEDILLA}"  # windows-1257:BA
+        "\N{LATIN SMALL LETTER S WITH ACUTE}"  # windows-1250:9C
+        "\N{LATIN SMALL LETTER S WITH CARON}"  # windows-1252:9A
+        "\N{LATIN SMALL LETTER S WITH CEDILLA}"  # windows-1250:BA
+        "\N{LATIN SMALL LETTER T WITH CARON}"  # windows-1250:9D
+        "\N{LATIN SMALL LETTER Z WITH ACUTE}"  # windows-1250:9F
+        "\N{LATIN SMALL LETTER Z WITH CARON}"  # windows-1252:9E
+        "\N{LATIN SMALL LETTER Z WITH DOT ABOVE}"  # windows-1250:BF
+        "\N{LATIN SMALL LIGATURE OE}"  # windows-1252:9C
+        "\N{MODIFIER LETTER CIRCUMFLEX ACCENT}"  # windows-1252:88
+        "\N{CARON}"  # windows-1250:A1
+        "\N{BREVE}"  # windows-1250:A2
+        "\N{OGONEK}"  # windows-1250:B2
+        "\N{SMALL TILDE}"  # windows-1252:98
+        "\N{DOUBLE ACUTE ACCENT}"  # windows-1250:BD
+        "\N{GREEK TONOS}"  # windows-1253:B4
+        "\N{GREEK DIALYTIKA TONOS}"  # windows-1253:A1
+        "\N{GREEK CAPITAL LETTER ALPHA WITH TONOS}"  # windows-1253:A2
+        "\N{GREEK CAPITAL LETTER EPSILON WITH TONOS}"  # windows-1253:B8
+        "\N{GREEK CAPITAL LETTER ETA WITH TONOS}"  # windows-1253:B9
+        "\N{GREEK CAPITAL LETTER IOTA WITH TONOS}"  # windows-1253:BA
+        "\N{GREEK CAPITAL LETTER OMICRON WITH TONOS}"  # windows-1253:BC
+        "\N{GREEK CAPITAL LETTER UPSILON WITH TONOS}"  # windows-1253:BE
+        "\N{GREEK CAPITAL LETTER OMEGA WITH TONOS}"  # windows-1253:BF
+        "\N{CYRILLIC CAPITAL LETTER IO}"  # windows-1251:A8
+        "\N{CYRILLIC CAPITAL LETTER DJE}"  # windows-1251:80
+        "\N{CYRILLIC CAPITAL LETTER GJE}"  # windows-1251:81
+        "\N{CYRILLIC CAPITAL LETTER UKRAINIAN IE}"  # windows-1251:AA
+        "\N{CYRILLIC CAPITAL LETTER DZE}"  # windows-1251:BD
+        "\N{CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I}"  # windows-1251:B2
+        "\N{CYRILLIC CAPITAL LETTER YI}"  # windows-1251:AF
+        "\N{CYRILLIC CAPITAL LETTER JE}"  # windows-1251:A3
+        "\N{CYRILLIC CAPITAL LETTER LJE}"  # windows-1251:8A
+        "\N{CYRILLIC CAPITAL LETTER NJE}"  # windows-1251:8C
+        "\N{CYRILLIC CAPITAL LETTER TSHE}"  # windows-1251:8E
+        "\N{CYRILLIC CAPITAL LETTER KJE}"  # windows-1251:8D
+        "\N{CYRILLIC CAPITAL LETTER SHORT U}"  # windows-1251:A1
+        "\N{CYRILLIC CAPITAL LETTER DZHE}"  # windows-1251:8F
+        "\N{CYRILLIC SMALL LETTER IO}"  # windows-1251:B8
+        "\N{CYRILLIC SMALL LETTER DJE}"  # windows-1251:90
+        "\N{CYRILLIC SMALL LETTER GJE}"  # windows-1251:83
+        "\N{CYRILLIC SMALL LETTER UKRAINIAN IE}"  # windows-1251:BA
+        "\N{CYRILLIC SMALL LETTER DZE}"  # windows-1251:BE
+        "\N{CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I}"  # windows-1251:B3
+        "\N{CYRILLIC SMALL LETTER YI}"  # windows-1251:BF
+        "\N{CYRILLIC SMALL LETTER JE}"  # windows-1251:BC
+        "\N{CYRILLIC SMALL LETTER LJE}"  # windows-1251:9A
+        "\N{CYRILLIC SMALL LETTER NJE}"  # windows-1251:9C
+        "\N{CYRILLIC SMALL LETTER TSHE}"  # windows-1251:9E
+        "\N{CYRILLIC SMALL LETTER KJE}"  # windows-1251:9D
+        "\N{CYRILLIC SMALL LETTER SHORT U}"  # windows-1251:A2
+        "\N{CYRILLIC SMALL LETTER DZHE}"  # windows-1251:9F
+        "\N{CYRILLIC CAPITAL LETTER GHE WITH UPTURN}"  # windows-1251:A5
+        "\N{CYRILLIC SMALL LETTER GHE WITH UPTURN}"  # windows-1251:B4
+        "\N{DAGGER}"  # windows-1252:86
+        "\N{DOUBLE DAGGER}"  # windows-1252:87
+        "\N{PER MILLE SIGN}"  # windows-1252:89
+        "\N{SINGLE LEFT-POINTING ANGLE QUOTATION MARK}"  # windows-1252:8B
+        "\N{SINGLE RIGHT-POINTING ANGLE QUOTATION MARK}"  # windows-1252:9B
+        "\N{EURO SIGN}"  # windows-1252:80
+        "\N{NUMERO SIGN}"  # windows-1251:B9
+        "\N{TRADE MARK SIGN}"  # windows-1252:99
+    ),
+}
+
+# This regex uses UTF8_CLUES to find sequences of likely mojibake.
+# It matches them with + so that several adjacent UTF-8-looking sequences
+# get coalesced into one, allowing them to be fixed more efficiently
+# and not requiring every individual subsequence to be detected as 'badness'.
+#
+# We accept spaces in place of "utf8_continuation", because spaces might have
+# been intended to be U+A0 NO-BREAK SPACE.
+#
+# We do a lookbehind to make sure the previous character isn't a
+# "utf8_continuation_strict" character, so that we don't fix just a few
+# characters in a huge garble and make the situation worse.
+#
+# Unfortunately, the matches to this regular expression won't show their
+# surrounding context, and including context would make the expression much
+# less efficient. The 'badness' rules that require context, such as a preceding
+# lowercase letter, will prevent some cases of inconsistent UTF-8 from being
+# fixed when they don't see it.
+UTF8_DETECTOR_RE = re.compile(
+    """
+    (?<! [{utf8_continuation_strict}])
+    (
+        [{utf8_first_of_2}] [{utf8_continuation}]
+        |
+        [{utf8_first_of_3}] [{utf8_continuation}]{{2}}
+        |
+        [{utf8_first_of_4}] [{utf8_continuation}]{{3}}
+    )+
+    """.format(**UTF8_CLUES),
+    re.VERBOSE,
+)

evalkit_tf437/lib/python3.10/site-packages/ftfy/fixes.py

@@ -0,0 +1,510 @@
+"""
+The `ftfy.fixes` module contains the individual fixes that :func:`ftfy.fix_text`
+can perform, and provides the functions that are named in "explanations"
+such as the output of :func:`ftfy.fix_and_explain`.
+
+Two of these functions are particularly useful on their own, as more robust
+versions of functions in the Python standard library:
+
+- :func:`ftfy.fixes.decode_escapes`
+- :func:`ftfy.fixes.unescape_html`
+"""
+
+import codecs
+import html
+import re
+import warnings
+from re import Match
+from typing import Any
+
+import ftfy
+from ftfy.badness import is_bad
+from ftfy.chardata import (
+    ALTERED_UTF8_RE,
+    C1_CONTROL_RE,
+    CONTROL_CHARS,
+    DOUBLE_QUOTE_RE,
+    HTML_ENTITIES,
+    HTML_ENTITY_RE,
+    LIGATURES,
+    LOSSY_UTF8_RE,
+    SINGLE_QUOTE_RE,
+    UTF8_DETECTOR_RE,
+    WIDTH_MAP,
+)
+
+
+def fix_encoding_and_explain(text: str) -> Any:
+    """
+    Deprecated copy of `ftfy.fix_encoding_and_explain()`.
+    """
+    warnings.warn(
+        "`fix_encoding_and_explain()` has moved to the main module of ftfy.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return ftfy.fix_encoding_and_explain(text)
+
+
+def fix_encoding(text: str) -> str:
+    """
+    Deprecated copy of `ftfy.fix_encoding()`.
+    """
+    warnings.warn(
+        "`fix_encoding()` has moved to the main module of ftfy.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return ftfy.fix_encoding(text)
+
+
+def apply_plan(text: str, plan: list[tuple[str, str]]) -> str:
+    """
+    Deprecated copy of `ftfy.apply_plan()`.
+    """
+    warnings.warn(
+        "`apply_plan()` has moved to the main module of ftfy.",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return ftfy.apply_plan(text, plan)
+
+
+def _unescape_fixup(match: Match[str]) -> str:
+    """
+    Replace one matched HTML entity with the character it represents,
+    if possible.
+    """
+    text = match.group(0)
+    if text in HTML_ENTITIES:
+        return HTML_ENTITIES[text]
+    elif text.startswith("&#"):
+        unescaped: str = html.unescape(text)
+
+        # If html.unescape only decoded part of the string, that's not what
+        # we want. The semicolon should be consumed.
+        if ";" in unescaped:
+            return text
+        else:
+            return unescaped
+    else:
+        return text
+
+
+def unescape_html(text: str) -> str:
+    """
+    Decode HTML entities and character references, including some nonstandard
+    ones written in all-caps.
+
+    Python has a built-in called `html.unescape` that can decode HTML escapes,
+    including a bunch of messy edge cases such as decoding escapes without
+    semicolons such as "&amp".
+
+    If you know you've got HTML-escaped text, applying `html.unescape` is the
+    right way to convert it to plain text. But in ambiguous situations, that
+    would create false positives. For example, the informally written text
+    "this&not that" should not automatically be decoded as "this¬ that".
+
+    In this function, we decode the escape sequences that appear in the
+    `html.entities.html5` dictionary, as long as they are the unambiguous ones
+    that end in semicolons.
+
+    We also decode all-caps versions of Latin letters and common symbols.
+    If a database contains the name 'PÉREZ', we can read that and intuit
+    that it was supposed to say 'PÉREZ'. This is limited to a smaller set of
+    entities, because there are many instances where entity names are
+    case-sensitive in complicated ways.
+
+        >>> unescape_html('<tag>')
+        '<tag>'
+
+        >>> unescape_html('&Jscr;ohn &HilbertSpace;ancock')
+        '𝒥ohn ℋancock'
+
+        >>> unescape_html('&checkmark;')
+        '✓'
+
+        >>> unescape_html('P&eacute;rez')
+        'Pérez'
+
+        >>> unescape_html('P&EACUTE;REZ')
+        'PÉREZ'
+
+        >>> unescape_html('BUNDESSTRA&SZLIG;E')
+        'BUNDESSTRASSE'
+
+        >>> unescape_html('&ntilde; &Ntilde; &NTILDE; &nTILDE;')
+        'ñ Ñ Ñ &nTILDE;'
+    """
+    return HTML_ENTITY_RE.sub(_unescape_fixup, text)
+
+
+ANSI_RE = re.compile("\033\\[((?:\\d|;)*)([a-zA-Z])")
+
+
+def remove_terminal_escapes(text: str) -> str:
+    r"""
+    Strip out "ANSI" terminal escape sequences, such as those that produce
+    colored text on Unix.
+
+        >>> print(remove_terminal_escapes(
+        ...     "\033[36;44mI'm blue, da ba dee da ba doo...\033[0m"
+        ... ))
+        I'm blue, da ba dee da ba doo...
+    """
+    return ANSI_RE.sub("", text)
+
+
+def uncurl_quotes(text: str) -> str:
+    r"""
+    Replace curly quotation marks with straight equivalents.
+
+        >>> print(uncurl_quotes('\u201chere\u2019s a test\u201d'))
+        "here's a test"
+    """
+    return SINGLE_QUOTE_RE.sub("'", DOUBLE_QUOTE_RE.sub('"', text))
+
+
+def fix_latin_ligatures(text: str) -> str:
+    """
+    Replace single-character ligatures of Latin letters, such as 'fi', with the
+    characters that they contain, as in 'fi'. Latin ligatures are usually not
+    intended in text strings (though they're lovely in *rendered* text).  If
+    you have such a ligature in your string, it is probably a result of a
+    copy-and-paste glitch.
+
+    We leave ligatures in other scripts alone to be safe. They may be intended,
+    and removing them may lose information. If you want to take apart nearly
+    all ligatures, use NFKC normalization.
+
+        >>> print(fix_latin_ligatures("fluffiest"))
+        fluffiest
+    """
+    return text.translate(LIGATURES)
+
+
+def fix_character_width(text: str) -> str:
+    """
+    The ASCII characters, katakana, and Hangul characters have alternate
+    "halfwidth" or "fullwidth" forms that help text line up in a grid.
+
+    If you don't need these width properties, you probably want to replace
+    these characters with their standard form, which is what this function
+    does.
+
+    Note that this replaces the ideographic space, U+3000, with the ASCII
+    space, U+20.
+
+        >>> print(fix_character_width("ＬＯＵＤ　ＮＯＩＳＥＳ"))
+        LOUD NOISES
+        >>> print(fix_character_width("Ｕﾀｰﾝ"))   # this means "U-turn"
+        Uターン
+    """
+    return text.translate(WIDTH_MAP)
+
+
+def fix_line_breaks(text: str) -> str:
+    r"""
+    Convert all line breaks to Unix style.
+
+    This will convert the following sequences into the standard \\n
+    line break:
+
+    - CRLF (\\r\\n), used on Windows and in some communication protocols
+    - CR (\\r), once used on Mac OS Classic, and now kept alive by misguided
+      software such as Microsoft Office for Mac
+    - LINE SEPARATOR (\\u2028) and PARAGRAPH SEPARATOR (\\u2029), defined by
+      Unicode and used to sow confusion and discord
+    - NEXT LINE (\\x85), a C1 control character that is certainly not what you
+      meant
+
+    The NEXT LINE character is a bit of an odd case, because it
+    usually won't show up if `fix_encoding` is also being run.
+    \\x85 is very common mojibake for \\u2026, HORIZONTAL ELLIPSIS.
+
+        >>> print(fix_line_breaks(
+        ...     "This string is made of two things:\u2029"
+        ...     "1. Unicode\u2028"
+        ...     "2. Spite"
+        ... ))
+        This string is made of two things:
+        1. Unicode
+        2. Spite
+
+    For further testing and examples, let's define a function to make sure
+    we can see the control characters in their escaped form:
+
+        >>> def eprint(text):
+        ...     print(text.encode('unicode-escape').decode('ascii'))
+
+        >>> eprint(fix_line_breaks("Content-type: text/plain\r\n\r\nHi."))
+        Content-type: text/plain\n\nHi.
+
+        >>> eprint(fix_line_breaks("This is how Microsoft \r trolls Mac users"))
+        This is how Microsoft \n trolls Mac users
+
+        >>> eprint(fix_line_breaks("What is this \x85 I don't even"))
+        What is this \n I don't even
+    """
+    return (
+        text.replace("\r\n", "\n")
+        .replace("\r", "\n")
+        .replace("\u2028", "\n")
+        .replace("\u2029", "\n")
+        .replace("\u0085", "\n")
+    )
+
+
+SURROGATE_RE = re.compile("[\ud800-\udfff]")
+SURROGATE_PAIR_RE = re.compile("[\ud800-\udbff][\udc00-\udfff]")
+
+
+def convert_surrogate_pair(match: Match[str]) -> str:
+    """
+    Convert a surrogate pair to the single codepoint it represents.
+
+    This implements the formula described at:
+    http://en.wikipedia.org/wiki/Universal_Character_Set_characters#Surrogates
+    """
+    pair = match.group(0)
+    codept = 0x10000 + (ord(pair[0]) - 0xD800) * 0x400 + (ord(pair[1]) - 0xDC00)
+    return chr(codept)
+
+
+def fix_surrogates(text: str) -> str:
+    """
+    Replace 16-bit surrogate codepoints with the characters they represent
+    (when properly paired), or with \ufffd otherwise.
+
+        >>> high_surrogate = chr(0xd83d)
+        >>> low_surrogate = chr(0xdca9)
+        >>> print(fix_surrogates(high_surrogate + low_surrogate))
+        💩
+        >>> print(fix_surrogates(low_surrogate + high_surrogate))
+        ��
+
+    The above doctest had to be very carefully written, because even putting
+    the Unicode escapes of the surrogates in the docstring was causing
+    various tools to fail, which I think just goes to show why this fixer is
+    necessary.
+    """
+    if SURROGATE_RE.search(text):
+        text = SURROGATE_PAIR_RE.sub(convert_surrogate_pair, text)
+        text = SURROGATE_RE.sub("\ufffd", text)
+    return text
+
+
+def remove_control_chars(text: str) -> str:
+    """
+    Remove various control characters that you probably didn't intend to be in
+    your text. Many of these characters appear in the table of "Characters not
+    suitable for use with markup" at
+    http://www.unicode.org/reports/tr20/tr20-9.html.
+
+    This includes:
+
+    - ASCII control characters, except for the important whitespace characters
+      (U+00 to U+08, U+0B, U+0E to U+1F, U+7F)
+    - Deprecated Arabic control characters (U+206A to U+206F)
+    - Interlinear annotation characters (U+FFF9 to U+FFFB)
+    - The Object Replacement Character (U+FFFC)
+    - The byte order mark (U+FEFF)
+
+    However, these similar characters are left alone:
+
+    - Control characters that produce whitespace (U+09, U+0A, U+0C, U+0D,
+      U+2028, and U+2029)
+    - C1 control characters (U+80 to U+9F) -- even though they are basically
+      never used intentionally, they are important clues about what mojibake
+      has happened
+    - Control characters that affect glyph rendering, such as joiners and
+      right-to-left marks (U+200C to U+200F, U+202A to U+202E)
+    - Musical notation control characters (U+1D173 to U+1D17A) because wow if
+      you're using those you probably have a good reason
+    - Tag characters, because they are now used in emoji sequences such as
+      "Flag of Wales"
+    """
+    return text.translate(CONTROL_CHARS)
+
+
+def remove_bom(text: str) -> str:
+    r"""
+    Remove a byte-order mark that was accidentally decoded as if it were part
+    of the text.
+
+    >>> print(remove_bom(chr(0xfeff) + "Where do you want to go today?"))
+    Where do you want to go today?
+    """
+    return text.lstrip(chr(0xFEFF))
+
+
+# Define a regex to match valid escape sequences in Python string literals.
+ESCAPE_SEQUENCE_RE = re.compile(
+    r"""
+    ( \\U........      # 8-digit hex escapes
+    | \\u....          # 4-digit hex escapes
+    | \\x..            # 2-digit hex escapes
+    | \\[0-7]{1,3}     # Octal escapes
+    | \\N\{[^}]+\}     # Unicode characters by name
+    | \\[\\'"abfnrtv]  # Single-character escapes
+    )""",
+    re.UNICODE | re.VERBOSE,
+)
+
+
+def decode_escapes(text: str) -> str:
+    r"""
+    Decode backslashed escape sequences, including \\x, \\u, and \\U character
+    references, even in the presence of other Unicode.
+
+    This function has to be called specifically. It's not run automatically by
+    ftfy, because escaped text is not necessarily a mistake, and there is no
+    way to distinguish when it is.
+
+    This is what Python's "string-escape" and "unicode-escape" codecs were
+    meant to do, but in contrast, this actually works. It will decode the
+    string exactly the same way that the Python interpreter decodes its string
+    literals.
+
+        >>> factoid = '\\u20a1 is the currency symbol for the colón.'
+        >>> print(factoid[1:])
+        u20a1 is the currency symbol for the colón.
+        >>> print(decode_escapes(factoid))
+        ₡ is the currency symbol for the colón.
+
+    Even though Python itself can read string literals with a combination of
+    escapes and literal Unicode -- you're looking at one right now -- the
+    "unicode-escape" codec doesn't work on literal Unicode. (See
+    http://stackoverflow.com/a/24519338/773754 for more details.)
+
+    Instead, this function searches for just the parts of a string that
+    represent escape sequences, and decodes them, leaving the rest alone. All
+    valid escape sequences are made of ASCII characters, and this allows
+    "unicode-escape" to work correctly.
+    """
+
+    def decode_match(match: Match[str]) -> str:
+        "Given a regex match, decode the escape sequence it contains."
+        return codecs.decode(match.group(0), "unicode-escape")
+
+    return ESCAPE_SEQUENCE_RE.sub(decode_match, text)
+
+
+# This regex implements an exception to restore_byte_a0, so we can decode the
+# very common mojibake of (for example) "Ã la mode" as "à la mode", not "àla
+# mode".
+#
+# If byte C3 appears with a single space after it -- most commonly this shows
+# up as " Ã " appearing as an entire word -- we'll insert \xa0 while keeping
+# the space. Without this change, we would decode "à" as the start of the next
+# word, such as "àla". It's almost always intended to be a separate word, as in
+# "à la", but when mojibake turns this into "Ã\xa0 la", the two kinds of spaces
+# get coalesced into "Ã la".
+#
+# We make exceptions for the Portuguese words "às", "àquele", "àquela",
+# "àquilo" and their plurals -- these are contractions of, for example, "a
+# aquele" and are very common. Note that the final letter is important to
+# distinguish this case from French "à quel point".
+#
+# Other instances in Portuguese, such as "àfrica", seem to be typos (intended
+# to be "África" with the accent in the other direction).
+#
+# Unfortunately, "à" is a common letter in Catalan, and mojibake of words that
+# contain it will end up with inserted spaces. We can't do the right thing with
+# every word. The cost is that the mojibake text "fà cil" will be interpreted as
+# "fà cil", not "fàcil".
+A_GRAVE_WORD_RE = re.compile(b"\xc3 (?! |quele|quela|quilo|s )")
+
+
+def restore_byte_a0(byts: bytes) -> bytes:
+    """
+    Some mojibake has been additionally altered by a process that said "hmm,
+    byte A0, that's basically a space!" and replaced it with an ASCII space.
+    When the A0 is part of a sequence that we intend to decode as UTF-8,
+    changing byte A0 to 20 would make it fail to decode.
+
+    This process finds sequences that would convincingly decode as UTF-8 if
+    byte 20 were changed to A0, and puts back the A0. For the purpose of
+    deciding whether this is a good idea, this step gets a cost of twice
+    the number of bytes that are changed.
+
+    This is used as a step within `fix_encoding`.
+    """
+    byts = A_GRAVE_WORD_RE.sub(b"\xc3\xa0 ", byts)
+
+    def replacement(match: Match[bytes]) -> bytes:
+        "The function to apply when this regex matches."
+        return match.group(0).replace(b"\x20", b"\xa0")
+
+    return ALTERED_UTF8_RE.sub(replacement, byts)
+
+
+def replace_lossy_sequences(byts: bytes) -> bytes:
+    """
+    This function identifies sequences where information has been lost in
+    a "sloppy" codec, indicated by byte 1A, and if they would otherwise look
+    like a UTF-8 sequence, it replaces them with the UTF-8 sequence for U+FFFD.
+
+    A further explanation:
+
+    ftfy can now fix text in a few cases that it would previously fix
+    incompletely, because of the fact that it can't successfully apply the fix
+    to the entire string. A very common case of this is when characters have
+    been erroneously decoded as windows-1252, but instead of the "sloppy"
+    windows-1252 that passes through unassigned bytes, the unassigned bytes get
+    turned into U+FFFD (�), so we can't tell what they were.
+
+    This most commonly happens with curly quotation marks that appear
+    ``“ like this �``.
+
+    We can do better by building on ftfy's "sloppy codecs" to let them handle
+    less-sloppy but more-lossy text. When they encounter the character ``�``,
+    instead of refusing to encode it, they encode it as byte 1A -- an
+    ASCII control code called SUBSTITUTE that once was meant for about the same
+    purpose. We can then apply a fixer that looks for UTF-8 sequences where
+    some continuation bytes have been replaced by byte 1A, and decode the whole
+    sequence as �; if that doesn't work, it'll just turn the byte back into �
+    itself.
+
+    As a result, the above text ``“ like this �`` will decode as
+    ``“ like this �``.
+
+    If U+1A was actually in the original string, then the sloppy codecs will
+    not be used, and this function will not be run, so your weird control
+    character will be left alone but wacky fixes like this won't be possible.
+
+    This is used as a transcoder within `fix_encoding`.
+    """
+    return LOSSY_UTF8_RE.sub("\ufffd".encode(), byts)
+
+
+def decode_inconsistent_utf8(text: str) -> str:
+    """
+    Sometimes, text from one encoding ends up embedded within text from a
+    different one. This is common enough that we need to be able to fix it.
+
+    This is used as a transcoder within `fix_encoding`.
+    """
+
+    def fix_embedded_mojibake(match: Match[str]) -> str:
+        substr = match.group(0)
+
+        # Require the match to be shorter, so that this doesn't recurse infinitely
+        if len(substr) < len(text) and is_bad(substr):
+            return ftfy.fix_encoding(substr)
+        else:
+            return substr
+
+    return UTF8_DETECTOR_RE.sub(fix_embedded_mojibake, text)
+
+
+def _c1_fixer(match: Match[str]) -> str:
+    return match.group(0).encode("latin-1").decode("sloppy-windows-1252")
+
+
+def fix_c1_controls(text: str) -> str:
+    """
+    If text still contains C1 control characters, treat them as their
+    Windows-1252 equivalents. This matches what Web browsers do.
+    """
+    return C1_CONTROL_RE.sub(_c1_fixer, text)

evalkit_tf437/lib/python3.10/site-packages/openpyxl/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2010-2024 openpyxl
+
+DEBUG = False
+
+from openpyxl.compat.numbers import NUMPY
+from openpyxl.xml import DEFUSEDXML, LXML
+from openpyxl.workbook import Workbook
+from openpyxl.reader.excel import load_workbook as open
+from openpyxl.reader.excel import load_workbook
+import openpyxl._constants as constants
+
+# Expose constants especially the version number
+
+__author__ = constants.__author__
+__author_email__ = constants.__author_email__
+__license__ = constants.__license__
+__maintainer_email__ = constants.__maintainer_email__
+__url__ = constants.__url__
+__version__ = constants.__version__

evalkit_tf437/lib/python3.10/site-packages/openpyxl/_constants.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2010-2024 openpyxl
+
+"""
+Package metadata
+"""
+
+__author__ = "See AUTHORS"
+__author_email__ = "[email protected]"
+__license__ = "MIT"
+__maintainer_email__ = "[email protected]"
+__url__ = "https://openpyxl.readthedocs.io"
+__version__ = "3.1.5"
+__python__ = "3.8"

evalkit_tf437/lib/python3.10/site-packages/openpyxl/chartsheet/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from .chartsheet import Chartsheet

evalkit_tf437/lib/python3.10/site-packages/openpyxl/chartsheet/custom.py

@@ -0,0 +1,61 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.worksheet.header_footer import HeaderFooter
+
+from openpyxl.descriptors import (
+    Bool,
+    Integer,
+    Set,
+    Typed,
+    Sequence
+)
+from openpyxl.descriptors.excel import Guid
+from openpyxl.descriptors.serialisable import Serialisable
+from openpyxl.worksheet.page import (
+    PageMargins,
+    PrintPageSetup
+)
+
+
+class CustomChartsheetView(Serialisable):
+    tagname = "customSheetView"
+
+    guid = Guid()
+    scale = Integer()
+    state = Set(values=(['visible', 'hidden', 'veryHidden']))
+    zoomToFit = Bool(allow_none=True)
+    pageMargins = Typed(expected_type=PageMargins, allow_none=True)
+    pageSetup = Typed(expected_type=PrintPageSetup, allow_none=True)
+    headerFooter = Typed(expected_type=HeaderFooter, allow_none=True)
+
+    __elements__ = ('pageMargins', 'pageSetup', 'headerFooter')
+
+    def __init__(self,
+                 guid=None,
+                 scale=None,
+                 state='visible',
+                 zoomToFit=None,
+                 pageMargins=None,
+                 pageSetup=None,
+                 headerFooter=None,
+                 ):
+        self.guid = guid
+        self.scale = scale
+        self.state = state
+        self.zoomToFit = zoomToFit
+        self.pageMargins = pageMargins
+        self.pageSetup = pageSetup
+        self.headerFooter = headerFooter
+
+
+class CustomChartsheetViews(Serialisable):
+    tagname = "customSheetViews"
+
+    customSheetView = Sequence(expected_type=CustomChartsheetView, allow_none=True)
+
+    __elements__ = ('customSheetView',)
+
+    def __init__(self,
+                 customSheetView=None,
+                 ):
+        self.customSheetView = customSheetView

evalkit_tf437/lib/python3.10/site-packages/openpyxl/chartsheet/protection.py

@@ -0,0 +1,41 @@
+import hashlib
+
+from openpyxl.descriptors import (Bool, Integer, String)
+from openpyxl.descriptors.excel import Base64Binary
+from openpyxl.descriptors.serialisable import Serialisable
+
+from openpyxl.worksheet.protection import (
+    hash_password,
+    _Protected
+)
+
+
+class ChartsheetProtection(Serialisable, _Protected):
+    tagname = "sheetProtection"
+
+    algorithmName = String(allow_none=True)
+    hashValue = Base64Binary(allow_none=True)
+    saltValue = Base64Binary(allow_none=True)
+    spinCount = Integer(allow_none=True)
+    content = Bool(allow_none=True)
+    objects = Bool(allow_none=True)
+
+    __attrs__ = ("content", "objects", "password", "hashValue", "spinCount", "saltValue", "algorithmName")
+
+    def __init__(self,
+                 content=None,
+                 objects=None,
+                 hashValue=None,
+                 spinCount=None,
+                 saltValue=None,
+                 algorithmName=None,
+                 password=None,
+                 ):
+        self.content = content
+        self.objects = objects
+        self.hashValue = hashValue
+        self.spinCount = spinCount
+        self.saltValue = saltValue
+        self.algorithmName = algorithmName
+        if password is not None:
+            self.password = password

evalkit_tf437/lib/python3.10/site-packages/openpyxl/chartsheet/relation.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.descriptors import (
+    Integer,
+    Alias
+)
+from openpyxl.descriptors.excel import Relation
+from openpyxl.descriptors.serialisable import Serialisable
+
+
+class SheetBackgroundPicture(Serialisable):
+    tagname = "picture"
+    id = Relation()
+
+    def __init__(self, id):
+        self.id = id
+
+
+class DrawingHF(Serialisable):
+    id = Relation()
+    lho = Integer(allow_none=True)
+    leftHeaderOddPages = Alias('lho')
+    lhe = Integer(allow_none=True)
+    leftHeaderEvenPages = Alias('lhe')
+    lhf = Integer(allow_none=True)
+    leftHeaderFirstPage = Alias('lhf')
+    cho = Integer(allow_none=True)
+    centerHeaderOddPages = Alias('cho')
+    che = Integer(allow_none=True)
+    centerHeaderEvenPages = Alias('che')
+    chf = Integer(allow_none=True)
+    centerHeaderFirstPage = Alias('chf')
+    rho = Integer(allow_none=True)
+    rightHeaderOddPages = Alias('rho')
+    rhe = Integer(allow_none=True)
+    rightHeaderEvenPages = Alias('rhe')
+    rhf = Integer(allow_none=True)
+    rightHeaderFirstPage = Alias('rhf')
+    lfo = Integer(allow_none=True)
+    leftFooterOddPages = Alias('lfo')
+    lfe = Integer(allow_none=True)
+    leftFooterEvenPages = Alias('lfe')
+    lff = Integer(allow_none=True)
+    leftFooterFirstPage = Alias('lff')
+    cfo = Integer(allow_none=True)
+    centerFooterOddPages = Alias('cfo')
+    cfe = Integer(allow_none=True)
+    centerFooterEvenPages = Alias('cfe')
+    cff = Integer(allow_none=True)
+    centerFooterFirstPage = Alias('cff')
+    rfo = Integer(allow_none=True)
+    rightFooterOddPages = Alias('rfo')
+    rfe = Integer(allow_none=True)
+    rightFooterEvenPages = Alias('rfe')
+    rff = Integer(allow_none=True)
+    rightFooterFirstPage = Alias('rff')
+
+    def __init__(self,
+                 id=None,
+                 lho=None,
+                 lhe=None,
+                 lhf=None,
+                 cho=None,
+                 che=None,
+                 chf=None,
+                 rho=None,
+                 rhe=None,
+                 rhf=None,
+                 lfo=None,
+                 lfe=None,
+                 lff=None,
+                 cfo=None,
+                 cfe=None,
+                 cff=None,
+                 rfo=None,
+                 rfe=None,
+                 rff=None,
+                 ):
+        self.id = id
+        self.lho = lho
+        self.lhe = lhe
+        self.lhf = lhf
+        self.cho = cho
+        self.che = che
+        self.chf = chf
+        self.rho = rho
+        self.rhe = rhe
+        self.rhf = rhf
+        self.lfo = lfo
+        self.lfe = lfe
+        self.lff = lff
+        self.cfo = cfo
+        self.cfe = cfe
+        self.cff = cff
+        self.rfo = rfo
+        self.rfe = rfe
+        self.rff = rff

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/_read_only.py

@@ -0,0 +1,190 @@
+# Copyright (c) 2010-2024 openpyxl
+
+""" Read worksheets on-demand
+"""
+
+from .worksheet import Worksheet
+from openpyxl.cell.read_only import ReadOnlyCell, EMPTY_CELL
+from openpyxl.utils import get_column_letter
+
+from ._reader import WorkSheetParser
+from openpyxl.workbook.defined_name import DefinedNameDict
+
+
+def read_dimension(source):
+    parser = WorkSheetParser(source, [])
+    return parser.parse_dimensions()
+
+
+class ReadOnlyWorksheet:
+
+    _min_column = 1
+    _min_row = 1
+    _max_column = _max_row = None
+
+    # from Standard Worksheet
+    # Methods from Worksheet
+    cell = Worksheet.cell
+    iter_rows = Worksheet.iter_rows
+    values = Worksheet.values
+    rows = Worksheet.rows
+    __getitem__ = Worksheet.__getitem__
+    __iter__ = Worksheet.__iter__
+
+
+    def __init__(self, parent_workbook, title, worksheet_path, shared_strings):
+        self.parent = parent_workbook
+        self.title = title
+        self.sheet_state = 'visible'
+        self._current_row = None
+        self._worksheet_path = worksheet_path
+        self._shared_strings = shared_strings
+        self._get_size()
+        self.defined_names = DefinedNameDict()
+
+
+    def _get_size(self):
+        src = self._get_source()
+        parser = WorkSheetParser(src, [])
+        dimensions = parser.parse_dimensions()
+        src.close()
+        if dimensions is not None:
+            self._min_column, self._min_row, self._max_column, self._max_row = dimensions
+
+
+    def _get_source(self):
+        """Parse xml source on demand, must close after use"""
+        return self.parent._archive.open(self._worksheet_path)
+
+
+    def _cells_by_row(self, min_col, min_row, max_col, max_row, values_only=False):
+        """
+        The source worksheet file may have columns or rows missing.
+        Missing cells will be created.
+        """
+        filler = EMPTY_CELL
+        if values_only:
+            filler = None
+
+        max_col = max_col or self.max_column
+        max_row = max_row or self.max_row
+        empty_row = []
+        if max_col is not None:
+            empty_row = (filler,) * (max_col + 1 - min_col)
+
+        counter = min_row
+        idx = 1
+        with self._get_source() as src:
+            parser = WorkSheetParser(src,
+                                     self._shared_strings,
+                                     data_only=self.parent.data_only,
+                                     epoch=self.parent.epoch,
+                                     date_formats=self.parent._date_formats,
+                                     timedelta_formats=self.parent._timedelta_formats)
+
+            for idx, row in parser.parse():
+                if max_row is not None and idx > max_row:
+                    break
+
+                # some rows are missing
+                for _ in range(counter, idx):
+                    counter += 1
+                    yield empty_row
+
+                # return cells from a row
+                if counter <= idx:
+                    row = self._get_row(row, min_col, max_col, values_only)
+                    counter += 1
+                    yield row
+
+        if max_row is not None and max_row < idx:
+            for _ in range(counter, max_row+1):
+                yield empty_row
+
+
+    def _get_row(self, row, min_col=1, max_col=None, values_only=False):
+        """
+        Make sure a row contains always the same number of cells or values
+        """
+        if not row and not max_col: # in case someone wants to force rows where there aren't any
+            return ()
+
+        max_col = max_col or  row[-1]['column']
+        row_width = max_col + 1 - min_col
+
+        new_row = [EMPTY_CELL] * row_width
+        if values_only:
+            new_row = [None] * row_width
+
+        for cell in row:
+            counter = cell['column']
+            if min_col <= counter <= max_col:
+                idx = counter - min_col # position in list of cells returned
+                new_row[idx] = cell['value']
+                if not values_only:
+                    new_row[idx] = ReadOnlyCell(self, **cell)
+
+        return tuple(new_row)
+
+
+    def _get_cell(self, row, column):
+        """Cells are returned by a generator which can be empty"""
+        for row in self._cells_by_row(column, row, column, row):
+            if row:
+                return row[0]
+        return EMPTY_CELL
+
+
+    def calculate_dimension(self, force=False):
+        if not all([self.max_column, self.max_row]):
+            if force:
+                self._calculate_dimension()
+            else:
+                raise ValueError("Worksheet is unsized, use calculate_dimension(force=True)")
+        return f"{get_column_letter(self.min_column)}{self.min_row}:{get_column_letter(self.max_column)}{self.max_row}"
+
+
+    def _calculate_dimension(self):
+        """
+        Loop through all the cells to get the size of a worksheet.
+        Do this only if it is explicitly requested.
+        """
+
+        max_col = 0
+        for r in self.rows:
+            if not r:
+                continue
+            cell = r[-1]
+            max_col = max(max_col, cell.column)
+
+        self._max_row = cell.row
+        self._max_column = max_col
+
+
+    def reset_dimensions(self):
+        """
+        Remove worksheet dimensions if these are incorrect in the worksheet source.
+        NB. This probably indicates a bug in the library or application that created
+        the workbook.
+        """
+        self._max_row = self._max_column = None
+
+
+    @property
+    def min_row(self):
+        return self._min_row
+
+
+    @property
+    def max_row(self):
+        return self._max_row
+
+
+    @property
+    def min_column(self):
+        return self._min_column
+
+
+    @property
+    def max_column(self):
+        return self._max_column

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/_reader.py

@@ -0,0 +1,472 @@
+# Copyright (c) 2010-2024 openpyxl
+
+"""Reader for a single worksheet."""
+from copy import copy
+from warnings import warn
+
+# compatibility imports
+from openpyxl.xml.functions import iterparse
+
+# package imports
+from openpyxl.cell import Cell, MergedCell
+from openpyxl.cell.text import Text
+from openpyxl.worksheet.dimensions import (
+    ColumnDimension,
+    RowDimension,
+    SheetFormatProperties,
+)
+
+from openpyxl.xml.constants import (
+    SHEET_MAIN_NS,
+    EXT_TYPES,
+)
+from openpyxl.formatting.formatting import ConditionalFormatting
+from openpyxl.formula.translate import Translator
+from openpyxl.utils import (
+    get_column_letter,
+    coordinate_to_tuple,
+    )
+from openpyxl.utils.datetime import from_excel, from_ISO8601, WINDOWS_EPOCH
+from openpyxl.descriptors.excel import ExtensionList
+from openpyxl.cell.rich_text import CellRichText
+
+from .formula import DataTableFormula, ArrayFormula
+from .filters import AutoFilter
+from .header_footer import HeaderFooter
+from .hyperlink import HyperlinkList
+from .merge import MergeCells
+from .page import PageMargins, PrintOptions, PrintPageSetup
+from .pagebreak import RowBreak, ColBreak
+from .protection import SheetProtection
+from .scenario import ScenarioList
+from .views import SheetViewList
+from .datavalidation import DataValidationList
+from .table import TablePartList
+from .properties import WorksheetProperties
+from .dimensions import SheetDimension
+from .related import Related
+
+
+CELL_TAG = '{%s}c' % SHEET_MAIN_NS
+VALUE_TAG = '{%s}v' % SHEET_MAIN_NS
+FORMULA_TAG = '{%s}f' % SHEET_MAIN_NS
+MERGE_TAG = '{%s}mergeCells' % SHEET_MAIN_NS
+INLINE_STRING = "{%s}is" % SHEET_MAIN_NS
+COL_TAG = '{%s}col' % SHEET_MAIN_NS
+ROW_TAG = '{%s}row' % SHEET_MAIN_NS
+CF_TAG = '{%s}conditionalFormatting' % SHEET_MAIN_NS
+LEGACY_TAG = '{%s}legacyDrawing' % SHEET_MAIN_NS
+PROT_TAG = '{%s}sheetProtection' % SHEET_MAIN_NS
+EXT_TAG = "{%s}extLst" % SHEET_MAIN_NS
+HYPERLINK_TAG = "{%s}hyperlinks" % SHEET_MAIN_NS
+TABLE_TAG = "{%s}tableParts" % SHEET_MAIN_NS
+PRINT_TAG = '{%s}printOptions' % SHEET_MAIN_NS
+MARGINS_TAG = '{%s}pageMargins' % SHEET_MAIN_NS
+PAGE_TAG = '{%s}pageSetup' % SHEET_MAIN_NS
+HEADER_TAG = '{%s}headerFooter' % SHEET_MAIN_NS
+FILTER_TAG = '{%s}autoFilter' % SHEET_MAIN_NS
+VALIDATION_TAG = '{%s}dataValidations' % SHEET_MAIN_NS
+PROPERTIES_TAG = '{%s}sheetPr' % SHEET_MAIN_NS
+VIEWS_TAG = '{%s}sheetViews' % SHEET_MAIN_NS
+FORMAT_TAG = '{%s}sheetFormatPr' % SHEET_MAIN_NS
+ROW_BREAK_TAG = '{%s}rowBreaks' % SHEET_MAIN_NS
+COL_BREAK_TAG = '{%s}colBreaks' % SHEET_MAIN_NS
+SCENARIOS_TAG = '{%s}scenarios' % SHEET_MAIN_NS
+DATA_TAG = '{%s}sheetData' % SHEET_MAIN_NS
+DIMENSION_TAG = '{%s}dimension' % SHEET_MAIN_NS
+CUSTOM_VIEWS_TAG = '{%s}customSheetViews' % SHEET_MAIN_NS
+
+
+def _cast_number(value):
+    "Convert numbers as string to an int or float"
+    if "." in value or "E" in value or "e" in value:
+        return float(value)
+    return int(value)
+
+
+def parse_richtext_string(element):
+    """
+    Parse inline string and preserve rich text formatting
+    """
+    value = CellRichText.from_tree(element) or ""
+    if len(value) == 1 and isinstance(value[0], str):
+        value = value[0]
+    return value
+
+
+class WorkSheetParser:
+
+    def __init__(self, src, shared_strings, data_only=False,
+                 epoch=WINDOWS_EPOCH, date_formats=set(),
+                 timedelta_formats=set(), rich_text=False):
+        self.min_row = self.min_col = None
+        self.epoch = epoch
+        self.source = src
+        self.shared_strings = shared_strings
+        self.data_only = data_only
+        self.shared_formulae = {}
+        self.row_counter = self.col_counter = 0
+        self.tables = TablePartList()
+        self.date_formats = date_formats
+        self.timedelta_formats = timedelta_formats
+        self.row_dimensions = {}
+        self.column_dimensions = {}
+        self.number_formats = []
+        self.keep_vba = False
+        self.hyperlinks = HyperlinkList()
+        self.formatting = []
+        self.legacy_drawing = None
+        self.merged_cells = None
+        self.row_breaks = RowBreak()
+        self.col_breaks = ColBreak()
+        self.rich_text = rich_text
+
+
+    def parse(self):
+        dispatcher = {
+            COL_TAG: self.parse_column_dimensions,
+            PROT_TAG: self.parse_sheet_protection,
+            EXT_TAG: self.parse_extensions,
+            CF_TAG: self.parse_formatting,
+            LEGACY_TAG: self.parse_legacy,
+            ROW_BREAK_TAG: self.parse_row_breaks,
+            COL_BREAK_TAG: self.parse_col_breaks,
+            CUSTOM_VIEWS_TAG: self.parse_custom_views,
+                      }
+
+        properties = {
+            PRINT_TAG: ('print_options', PrintOptions),
+            MARGINS_TAG: ('page_margins', PageMargins),
+            PAGE_TAG: ('page_setup', PrintPageSetup),
+            HEADER_TAG: ('HeaderFooter', HeaderFooter),
+            FILTER_TAG: ('auto_filter', AutoFilter),
+            VALIDATION_TAG: ('data_validations', DataValidationList),
+            PROPERTIES_TAG: ('sheet_properties', WorksheetProperties),
+            VIEWS_TAG: ('views', SheetViewList),
+            FORMAT_TAG: ('sheet_format', SheetFormatProperties),
+            SCENARIOS_TAG: ('scenarios', ScenarioList),
+            TABLE_TAG: ('tables', TablePartList),
+            HYPERLINK_TAG: ('hyperlinks', HyperlinkList),
+            MERGE_TAG: ('merged_cells', MergeCells),
+
+        }
+
+        it = iterparse(self.source) # add a finaliser to close the source when this becomes possible
+
+        for _, element in it:
+            tag_name = element.tag
+            if tag_name in dispatcher:
+                dispatcher[tag_name](element)
+                element.clear()
+            elif tag_name in properties:
+                prop = properties[tag_name]
+                obj = prop[1].from_tree(element)
+                setattr(self, prop[0], obj)
+                element.clear()
+            elif tag_name == ROW_TAG:
+                row = self.parse_row(element)
+                element.clear()
+                yield row
+
+
+    def parse_dimensions(self):
+        """
+        Get worksheet dimensions if they are provided.
+        """
+        it = iterparse(self.source)
+
+        for _event, element in it:
+            if element.tag == DIMENSION_TAG:
+                dim = SheetDimension.from_tree(element)
+                return dim.boundaries
+
+            elif element.tag == DATA_TAG:
+                # Dimensions missing
+                break
+            element.clear()
+
+
+    def parse_cell(self, element):
+        data_type = element.get('t', 'n')
+        coordinate = element.get('r')
+        style_id = element.get('s', 0)
+        if style_id:
+            style_id = int(style_id)
+
+        if data_type == "inlineStr":
+            value = None
+        else:
+            value = element.findtext(VALUE_TAG, None) or None
+
+        if coordinate:
+            row, column = coordinate_to_tuple(coordinate)
+            self.col_counter = column
+        else:
+            self.col_counter += 1
+            row, column = self.row_counter, self.col_counter
+
+        if not self.data_only and element.find(FORMULA_TAG) is not None:
+            data_type = 'f'
+            value = self.parse_formula(element)
+
+        elif value is not None:
+            if data_type == 'n':
+                value = _cast_number(value)
+                if style_id in self.date_formats:
+                    data_type = 'd'
+                    try:
+                        value = from_excel(
+                            value, self.epoch, timedelta=style_id in self.timedelta_formats
+                        )
+                    except (OverflowError, ValueError):
+                        msg = f"""Cell {coordinate} is marked as a date but the serial value {value} is outside the limits for dates. The cell will be treated as an error."""
+                        warn(msg)
+                        data_type = "e"
+                        value = "#VALUE!"
+            elif data_type == 's':
+                value = self.shared_strings[int(value)]
+            elif data_type == 'b':
+                value = bool(int(value))
+            elif data_type == "str":
+                data_type = "s"
+            elif data_type == 'd':
+                value = from_ISO8601(value)
+
+        elif data_type == 'inlineStr':
+                child = element.find(INLINE_STRING)
+                if child is not None:
+                    data_type = 's'
+                    if self.rich_text:
+                        value = parse_richtext_string(child)
+                    else:
+                        value = Text.from_tree(child).content
+
+        return {'row':row, 'column':column, 'value':value, 'data_type':data_type, 'style_id':style_id}
+
+
+    def parse_formula(self, element):
+        """
+        possible formulae types: shared, array, datatable
+        """
+        formula = element.find(FORMULA_TAG)
+        formula_type = formula.get('t')
+        coordinate = element.get('r')
+        value = "="
+        if formula.text is not None:
+            value += formula.text
+
+        if formula_type == "array":
+            value = ArrayFormula(ref=formula.get('ref'), text=value)
+
+        elif formula_type == "shared":
+            idx = formula.get('si')
+            if idx in self.shared_formulae:
+                trans = self.shared_formulae[idx]
+                value = trans.translate_formula(coordinate)
+            elif value != "=":
+                self.shared_formulae[idx] = Translator(value, coordinate)
+
+        elif formula_type == "dataTable":
+            value = DataTableFormula(**formula.attrib)
+
+        return value
+
+
+    def parse_column_dimensions(self, col):
+        attrs = dict(col.attrib)
+        column = get_column_letter(int(attrs['min']))
+        attrs['index'] = column
+        self.column_dimensions[column] = attrs
+
+
+    def parse_row(self, row):
+        attrs = dict(row.attrib)
+
+        if "r" in attrs:
+            try:
+                self.row_counter = int(attrs['r'])
+            except ValueError:
+                val = float(attrs['r'])
+                if val.is_integer():
+                    self.row_counter = int(val)
+                else:
+                    raise ValueError(f"{attrs['r']} is not a valid row number")
+        else:
+            self.row_counter += 1
+        self.col_counter = 0
+
+        keys = {k for k in attrs if not k.startswith('{')}
+        if keys - {'r', 'spans'}:
+            # don't create dimension objects unless they have relevant information
+            self.row_dimensions[str(self.row_counter)] = attrs
+
+        cells = [self.parse_cell(el) for el in row]
+        return self.row_counter, cells
+
+
+    def parse_formatting(self, element):
+        try:
+            cf = ConditionalFormatting.from_tree(element)
+            self.formatting.append(cf)
+        except TypeError as e:
+            msg = f"Failed to load a conditional formatting rule. It will be discarded. Cause: {e}"
+            warn(msg)
+
+
+    def parse_sheet_protection(self, element):
+        protection = SheetProtection.from_tree(element)
+        password = element.get("password")
+        if password is not None:
+            protection.set_password(password, True)
+        self.protection = protection
+
+
+    def parse_extensions(self, element):
+        extLst = ExtensionList.from_tree(element)
+        for e in extLst.ext:
+            ext_type = EXT_TYPES.get(e.uri.upper(), "Unknown")
+            msg = "{0} extension is not supported and will be removed".format(ext_type)
+            warn(msg)
+
+
+    def parse_legacy(self, element):
+        obj = Related.from_tree(element)
+        self.legacy_drawing = obj.id
+
+
+    def parse_row_breaks(self, element):
+        brk = RowBreak.from_tree(element)
+        self.row_breaks = brk
+
+
+    def parse_col_breaks(self, element):
+        brk = ColBreak.from_tree(element)
+        self.col_breaks = brk
+
+
+    def parse_custom_views(self, element):
+        # clear page_breaks to avoid duplication which Excel doesn't like
+        # basically they're ignored in custom views
+        self.row_breaks = RowBreak()
+        self.col_breaks = ColBreak()
+
+
+class WorksheetReader:
+    """
+    Create a parser and apply it to a workbook
+    """
+
+    def __init__(self, ws, xml_source, shared_strings, data_only, rich_text):
+        self.ws = ws
+        self.parser = WorkSheetParser(xml_source, shared_strings,
+                data_only, ws.parent.epoch, ws.parent._date_formats,
+                ws.parent._timedelta_formats, rich_text)
+        self.tables = []
+
+
+    def bind_cells(self):
+        for idx, row in self.parser.parse():
+            for cell in row:
+                style = self.ws.parent._cell_styles[cell['style_id']]
+                c = Cell(self.ws, row=cell['row'], column=cell['column'], style_array=style)
+                c._value = cell['value']
+                c.data_type = cell['data_type']
+                self.ws._cells[(cell['row'], cell['column'])] = c
+
+        if self.ws._cells:
+            self.ws._current_row = self.ws.max_row # use cells not row dimensions
+
+
+    def bind_formatting(self):
+        for cf in self.parser.formatting:
+            for rule in cf.rules:
+                if rule.dxfId is not None:
+                    rule.dxf = self.ws.parent._differential_styles[rule.dxfId]
+                self.ws.conditional_formatting[cf] = rule
+
+
+    def bind_tables(self):
+        for t in self.parser.tables.tablePart:
+            rel = self.ws._rels.get(t.id)
+            self.tables.append(rel.Target)
+
+
+    def bind_merged_cells(self):
+        from openpyxl.worksheet.cell_range import MultiCellRange
+        from openpyxl.worksheet.merge import MergedCellRange
+        if not self.parser.merged_cells:
+            return
+
+        ranges = []
+        for cr in self.parser.merged_cells.mergeCell:
+            mcr = MergedCellRange(self.ws, cr.ref)
+            self.ws._clean_merge_range(mcr)
+            ranges.append(mcr)
+        self.ws.merged_cells = MultiCellRange(ranges)
+
+
+    def bind_hyperlinks(self):
+        for link in self.parser.hyperlinks.hyperlink:
+            if link.id:
+                rel = self.ws._rels.get(link.id)
+                link.target = rel.Target
+            if ":" in link.ref:
+                # range of cells
+                for row in self.ws[link.ref]:
+                    for cell in row:
+                        try:
+                            cell.hyperlink = copy(link)
+                        except AttributeError:
+                            pass
+            else:
+                cell = self.ws[link.ref]
+                if isinstance(cell, MergedCell):
+                    cell = self.normalize_merged_cell_link(cell.coordinate)
+                cell.hyperlink = link
+
+    def normalize_merged_cell_link(self, coord):
+        """
+        Returns the appropriate cell to which a hyperlink, which references a merged cell at the specified coordinates,
+        should be bound.
+        """
+        for rng in self.ws.merged_cells:
+            if coord in rng:
+                return self.ws.cell(*rng.top[0])
+
+    def bind_col_dimensions(self):
+        for col, cd in self.parser.column_dimensions.items():
+            if 'style' in cd:
+                key = int(cd['style'])
+                cd['style'] = self.ws.parent._cell_styles[key]
+            self.ws.column_dimensions[col] = ColumnDimension(self.ws, **cd)
+
+
+    def bind_row_dimensions(self):
+        for row, rd in self.parser.row_dimensions.items():
+            if 's' in rd:
+                key = int(rd['s'])
+                rd['s'] = self.ws.parent._cell_styles[key]
+            self.ws.row_dimensions[int(row)] = RowDimension(self.ws, **rd)
+
+
+    def bind_properties(self):
+        for k in ('print_options', 'page_margins', 'page_setup',
+                  'HeaderFooter', 'auto_filter', 'data_validations',
+                  'sheet_properties', 'views', 'sheet_format',
+                  'row_breaks', 'col_breaks', 'scenarios', 'legacy_drawing',
+                  'protection',
+                  ):
+            v = getattr(self.parser, k, None)
+            if v is not None:
+                setattr(self.ws, k, v)
+
+
+    def bind_all(self):
+        self.bind_cells()
+        self.bind_merged_cells()
+        self.bind_hyperlinks()
+        self.bind_formatting()
+        self.bind_col_dimensions()
+        self.bind_row_dimensions()
+        self.bind_tables()
+        self.bind_properties()

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/_write_only.py

@@ -0,0 +1,160 @@
+# Copyright (c) 2010-2024 openpyxl
+
+
+"""Write worksheets to xml representations in an optimized way"""
+
+from inspect import isgenerator
+
+from openpyxl.cell import Cell, WriteOnlyCell
+from openpyxl.workbook.child import _WorkbookChild
+from .worksheet import Worksheet
+from openpyxl.utils.exceptions import WorkbookAlreadySaved
+
+from ._writer import WorksheetWriter
+
+
+class WriteOnlyWorksheet(_WorkbookChild):
+    """
+    Streaming worksheet. Optimised to reduce memory by writing rows just in
+    time.
+    Cells can be styled and have comments Styles for rows and columns
+    must be applied before writing cells
+    """
+
+    __saved = False
+    _writer = None
+    _rows = None
+    _rel_type = Worksheet._rel_type
+    _path = Worksheet._path
+    mime_type = Worksheet.mime_type
+
+    # copy methods from Standard worksheet
+    _add_row = Worksheet._add_row
+    _add_column = Worksheet._add_column
+    add_chart = Worksheet.add_chart
+    add_image = Worksheet.add_image
+    add_table = Worksheet.add_table
+    tables = Worksheet.tables
+    print_titles = Worksheet.print_titles
+    print_title_cols = Worksheet.print_title_cols
+    print_title_rows = Worksheet.print_title_rows
+    freeze_panes = Worksheet.freeze_panes
+    print_area = Worksheet.print_area
+    sheet_view = Worksheet.sheet_view
+    _setup = Worksheet._setup
+
+    def __init__(self, parent, title):
+        super().__init__(parent, title)
+        self._max_col = 0
+        self._max_row = 0
+        self._setup()
+
+    @property
+    def closed(self):
+        return self.__saved
+
+
+    def _write_rows(self):
+        """
+        Send rows to the writer's stream
+        """
+        try:
+            xf = self._writer.xf.send(True)
+        except StopIteration:
+            self._already_saved()
+
+        with xf.element("sheetData"):
+            row_idx = 1
+            try:
+                while True:
+                    row = (yield)
+                    row = self._values_to_row(row, row_idx)
+                    self._writer.write_row(xf, row, row_idx)
+                    row_idx += 1
+            except GeneratorExit:
+                pass
+
+        self._writer.xf.send(None)
+
+
+    def _get_writer(self):
+        if self._writer is None:
+            self._writer = WorksheetWriter(self)
+            self._writer.write_top()
+
+
+    def close(self):
+        if self.__saved:
+            self._already_saved()
+
+        self._get_writer()
+
+        if self._rows is None:
+            self._writer.write_rows()
+        else:
+            self._rows.close()
+
+        self._writer.write_tail()
+
+        self._writer.close()
+        self.__saved = True
+
+
+    def append(self, row):
+        """
+        :param row: iterable containing values to append
+        :type row: iterable
+        """
+
+        if (not isgenerator(row) and
+            not isinstance(row, (list, tuple, range))
+            ):
+            self._invalid_row(row)
+
+        self._get_writer()
+
+        if self._rows is None:
+            self._rows = self._write_rows()
+            next(self._rows)
+
+        self._rows.send(row)
+
+
+    def _values_to_row(self, values, row_idx):
+        """
+        Convert whatever has been appended into a form suitable for work_rows
+        """
+        cell = WriteOnlyCell(self)
+
+        for col_idx, value in enumerate(values, 1):
+            if value is None:
+                continue
+            try:
+                cell.value = value
+            except ValueError:
+                if isinstance(value, Cell):
+                    cell = value
+                else:
+                    raise ValueError
+
+            cell.column = col_idx
+            cell.row = row_idx
+
+            if cell.hyperlink is not None:
+                cell.hyperlink.ref = cell.coordinate
+
+            yield cell
+
+            # reset cell if style applied
+            if cell.has_style or cell.hyperlink:
+                cell = WriteOnlyCell(self)
+
+
+    def _already_saved(self):
+        raise WorkbookAlreadySaved('Workbook has already been saved and cannot be modified or saved anymore.')
+
+
+    def _invalid_row(self, iterable):
+        raise TypeError('Value must be a list, tuple, range or a generator Supplied value is {0}'.format(
+            type(iterable))
+                        )

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/cell_range.py

@@ -0,0 +1,512 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from copy import copy
+from operator import attrgetter
+
+from openpyxl.descriptors import Strict
+from openpyxl.descriptors import MinMax
+from openpyxl.descriptors.sequence import UniqueSequence
+from openpyxl.descriptors.serialisable import Serialisable
+
+from openpyxl.utils import (
+    range_boundaries,
+    range_to_tuple,
+    get_column_letter,
+    quote_sheetname,
+)
+
+class CellRange(Serialisable):
+    """
+    Represents a range in a sheet: title and coordinates.
+
+    This object is used to perform operations on ranges, like:
+
+    - shift, expand or shrink
+    - union/intersection with another sheet range,
+
+    We can check whether a range is:
+
+    - equal or not equal to another,
+    - disjoint of another,
+    - contained in another.
+
+    We can get:
+
+    - the size of a range.
+    - the range bounds (vertices)
+    - the coordinates,
+    - the string representation,
+
+    """
+
+    min_col = MinMax(min=1, max=18278, expected_type=int)
+    min_row = MinMax(min=1, max=1048576, expected_type=int)
+    max_col = MinMax(min=1, max=18278, expected_type=int)
+    max_row = MinMax(min=1, max=1048576, expected_type=int)
+
+
+    def __init__(self, range_string=None, min_col=None, min_row=None,
+                 max_col=None, max_row=None, title=None):
+        if range_string is not None:
+            if "!" in range_string:
+                title, (min_col, min_row, max_col, max_row) = range_to_tuple(range_string)
+            else:
+                min_col, min_row, max_col, max_row = range_boundaries(range_string)
+
+        self.min_col = min_col
+        self.min_row = min_row
+        self.max_col = max_col
+        self.max_row = max_row
+        self.title = title
+
+        if min_col > max_col:
+            fmt = "{max_col} must be greater than {min_col}"
+            raise ValueError(fmt.format(min_col=min_col, max_col=max_col))
+        if min_row > max_row:
+            fmt = "{max_row} must be greater than {min_row}"
+            raise ValueError(fmt.format(min_row=min_row, max_row=max_row))
+
+
+    @property
+    def bounds(self):
+        """
+        Vertices of the range as a tuple
+        """
+        return self.min_col, self.min_row, self.max_col, self.max_row
+
+
+    @property
+    def coord(self):
+        """
+        Excel-style representation of the range
+        """
+        fmt = "{min_col}{min_row}:{max_col}{max_row}"
+        if (self.min_col == self.max_col
+            and self.min_row == self.max_row):
+            fmt = "{min_col}{min_row}"
+
+        return fmt.format(
+            min_col=get_column_letter(self.min_col),
+            min_row=self.min_row,
+            max_col=get_column_letter(self.max_col),
+            max_row=self.max_row
+        )
+
+    @property
+    def rows(self):
+        """
+        Return cell coordinates as rows
+        """
+        for row in range(self.min_row, self.max_row+1):
+            yield [(row, col) for col in range(self.min_col, self.max_col+1)]
+
+
+    @property
+    def cols(self):
+        """
+        Return cell coordinates as columns
+        """
+        for col in range(self.min_col, self.max_col+1):
+            yield [(row, col) for row in range(self.min_row, self.max_row+1)]
+
+
+    @property
+    def cells(self):
+        from itertools import product
+        return product(range(self.min_row, self.max_row+1), range(self.min_col, self.max_col+1))
+
+
+    def _check_title(self, other):
+        """
+        Check whether comparisons between ranges are possible.
+        Cannot compare ranges from different worksheets
+        Skip if the range passed in has no title.
+        """
+        if not isinstance(other, CellRange):
+            raise TypeError(repr(type(other)))
+
+        if other.title and self.title != other.title:
+            raise ValueError("Cannot work with ranges from different worksheets")
+
+
+    def __repr__(self):
+        fmt = u"<{cls} {coord}>"
+        if self.title:
+            fmt = u"<{cls} {title!r}!{coord}>"
+        return fmt.format(cls=self.__class__.__name__, title=self.title, coord=self.coord)
+
+
+    def __hash__(self):
+        return hash((self.min_row, self.min_col, self.max_row, self.max_col))
+
+
+    def __str__(self):
+        fmt = "{coord}"
+        title = self.title
+        if title:
+            fmt = u"{title}!{coord}"
+            title = quote_sheetname(title)
+        return fmt.format(title=title, coord=self.coord)
+
+
+    def __copy__(self):
+        return self.__class__(min_col=self.min_col, min_row=self.min_row,
+                              max_col=self.max_col, max_row=self.max_row,
+                              title=self.title)
+
+
+    def shift(self, col_shift=0, row_shift=0):
+        """
+        Shift the focus of the range according to the shift values (*col_shift*, *row_shift*).
+
+        :type col_shift: int
+        :param col_shift: number of columns to be moved by, can be negative
+        :type row_shift: int
+        :param row_shift: number of rows to be moved by, can be negative
+        :raise: :class:`ValueError` if any row or column index < 1
+        """
+
+        if (self.min_col + col_shift <= 0
+            or self.min_row + row_shift <= 0):
+            raise ValueError("Invalid shift value: col_shift={0}, row_shift={1}".format(col_shift, row_shift))
+        self.min_col += col_shift
+        self.min_row += row_shift
+        self.max_col += col_shift
+        self.max_row += row_shift
+
+
+    def __ne__(self, other):
+        """
+        Test whether the ranges are not equal.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range
+        :return: ``True`` if *range* != *other*.
+        """
+        try:
+            self._check_title(other)
+        except ValueError:
+            return True
+
+        return (
+            other.min_row != self.min_row
+            or self.max_row != other.max_row
+            or other.min_col != self.min_col
+            or self.max_col != other.max_col
+        )
+
+
+    def __eq__(self, other):
+        """
+        Test whether the ranges are equal.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range
+        :return: ``True`` if *range* == *other*.
+        """
+        return not self.__ne__(other)
+
+
+    def issubset(self, other):
+        """
+        Test whether every cell in this range is also in *other*.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range
+        :return: ``True`` if *range* <= *other*.
+        """
+        self._check_title(other)
+
+        return other.__superset(self)
+
+    __le__ = issubset
+
+
+    def __lt__(self, other):
+        """
+        Test whether *other* contains every cell of this range, and more.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range
+        :return: ``True`` if *range* < *other*.
+        """
+        return self.__le__(other) and self.__ne__(other)
+
+
+    def __superset(self, other):
+        return (
+            (self.min_row <= other.min_row <= other.max_row <= self.max_row)
+            and
+            (self.min_col <= other.min_col <= other.max_col <= self.max_col)
+        )
+
+
+    def issuperset(self, other):
+        """
+        Test whether every cell in *other* is in this range.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range
+        :return: ``True`` if *range* >= *other* (or *other* in *range*).
+        """
+        self._check_title(other)
+
+        return self.__superset(other)
+
+    __ge__ = issuperset
+
+
+    def __contains__(self, coord):
+        """
+        Check whether the range contains a particular cell coordinate
+        """
+        cr = self.__class__(coord)
+        return self.__superset(cr)
+
+
+    def __gt__(self, other):
+        """
+        Test whether this range contains every cell in *other*, and more.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range
+        :return: ``True`` if *range* > *other*.
+        """
+        return self.__ge__(other) and self.__ne__(other)
+
+
+    def isdisjoint(self, other):
+        """
+        Return ``True`` if this range has no cell in common with *other*.
+        Ranges are disjoint if and only if their intersection is the empty range.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range.
+        :return: ``True`` if the range has no cells in common with other.
+        """
+        self._check_title(other)
+
+        # Sort by top-left vertex
+        if self.bounds > other.bounds:
+            self, other = other, self
+
+        return (self.max_col < other.min_col
+                or self.max_row < other.min_row
+                or other.max_row < self.min_row)
+
+
+    def intersection(self, other):
+        """
+        Return a new range with cells common to this range and *other*
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range.
+        :return: the intersecting sheet range.
+        :raise: :class:`ValueError` if the *other* range doesn't intersect
+            with this range.
+        """
+        if self.isdisjoint(other):
+            raise ValueError("Range {0} doesn't intersect {0}".format(self, other))
+
+        min_row = max(self.min_row, other.min_row)
+        max_row = min(self.max_row, other.max_row)
+        min_col = max(self.min_col, other.min_col)
+        max_col = min(self.max_col, other.max_col)
+
+        return CellRange(min_col=min_col, min_row=min_row, max_col=max_col,
+                         max_row=max_row)
+
+    __and__ = intersection
+
+
+    def union(self, other):
+        """
+        Return the minimal superset of this range and *other*. This new range
+        will contain all cells from this range, *other*, and any additional
+        cells required to form a rectangular ``CellRange``.
+
+        :type other: openpyxl.worksheet.cell_range.CellRange
+        :param other: Other sheet range.
+        :return: a ``CellRange`` that is a superset of this and *other*.
+        """
+        self._check_title(other)
+
+        min_row = min(self.min_row, other.min_row)
+        max_row = max(self.max_row, other.max_row)
+        min_col = min(self.min_col, other.min_col)
+        max_col = max(self.max_col, other.max_col)
+        return CellRange(min_col=min_col, min_row=min_row, max_col=max_col,
+                         max_row=max_row, title=self.title)
+
+    __or__ = union
+
+
+    def __iter__(self):
+        """
+        For use as a dictionary elsewhere in the library.
+        """
+        for x in self.__attrs__:
+            if x == "title":
+                continue
+            v = getattr(self, x)
+            yield x, v
+
+
+    def expand(self, right=0, down=0, left=0, up=0):
+        """
+        Expand the range by the dimensions provided.
+
+        :type right: int
+        :param right: expand range to the right by this number of cells
+        :type down: int
+        :param down: expand range down by this number of cells
+        :type left: int
+        :param left: expand range to the left by this number of cells
+        :type up: int
+        :param up: expand range up by this number of cells
+        """
+        self.min_col -= left
+        self.min_row -= up
+        self.max_col += right
+        self.max_row += down
+
+
+    def shrink(self, right=0, bottom=0, left=0, top=0):
+        """
+        Shrink the range by the dimensions provided.
+
+        :type right: int
+        :param right: shrink range from the right by this number of cells
+        :type down: int
+        :param down: shrink range from the top by this number of cells
+        :type left: int
+        :param left: shrink range from the left by this number of cells
+        :type up: int
+        :param up: shrink range from the bottom by this number of cells
+        """
+        self.min_col += left
+        self.min_row += top
+        self.max_col -= right
+        self.max_row -= bottom
+
+
+    @property
+    def size(self):
+        """ Return the size of the range as a dictionary of rows and columns. """
+        cols = self.max_col + 1 - self.min_col
+        rows = self.max_row + 1 - self.min_row
+        return {'columns':cols, 'rows':rows}
+
+
+    @property
+    def top(self):
+        """A list of cell coordinates that comprise the top of the range"""
+        return [(self.min_row, col) for col in range(self.min_col, self.max_col+1)]
+
+
+    @property
+    def bottom(self):
+        """A list of cell coordinates that comprise the bottom of the range"""
+        return [(self.max_row, col) for col in range(self.min_col, self.max_col+1)]
+
+
+    @property
+    def left(self):
+        """A list of cell coordinates that comprise the left-side of the range"""
+        return [(row, self.min_col) for row in range(self.min_row, self.max_row+1)]
+
+
+    @property
+    def right(self):
+        """A list of cell coordinates that comprise the right-side of the range"""
+        return [(row, self.max_col) for row in range(self.min_row, self.max_row+1)]
+
+
+class MultiCellRange(Strict):
+
+
+    ranges = UniqueSequence(expected_type=CellRange)
+
+
+    def __init__(self, ranges=set()):
+        if isinstance(ranges, str):
+            ranges = [CellRange(r) for r in ranges.split()]
+        self.ranges = set(ranges)
+
+
+    def __contains__(self, coord):
+        if isinstance(coord, str):
+            coord = CellRange(coord)
+        for r in self.ranges:
+            if coord <= r:
+                return True
+        return False
+
+
+    def __repr__(self):
+        ranges = " ".join([str(r) for r in self.sorted()])
+        return f"<{self.__class__.__name__} [{ranges}]>"
+
+
+    def __str__(self):
+        ranges = u" ".join([str(r) for r in self.sorted()])
+        return ranges
+
+
+    def __hash__(self):
+        return hash(str(self))
+
+
+    def sorted(self):
+        """
+        Return a sorted list of items
+        """
+        return sorted(self.ranges, key=attrgetter('min_col', 'min_row', 'max_col', 'max_row'))
+
+
+    def add(self, coord):
+        """
+        Add a cell coordinate or CellRange
+        """
+        cr = coord
+        if isinstance(coord, str):
+            cr = CellRange(coord)
+        elif not isinstance(coord, CellRange):
+            raise ValueError("You can only add CellRanges")
+        if cr not in self:
+            self.ranges.add(cr)
+
+
+    def __iadd__(self, coord):
+        self.add(coord)
+        return self
+
+
+    def __eq__(self, other):
+        if  isinstance(other, str):
+            other = self.__class__(other)
+        return self.ranges == other.ranges
+
+
+    def __ne__(self, other):
+        return not self == other
+
+
+    def __bool__(self):
+        return bool(self.ranges)
+
+
+    def remove(self, coord):
+        if not isinstance(coord, CellRange):
+            coord = CellRange(coord)
+        self.ranges.remove(coord)
+
+
+    def __iter__(self):
+        for cr in self.ranges:
+            yield cr
+
+
+    def __copy__(self):
+        ranges = {copy(r) for r in self.ranges}
+        return MultiCellRange(ranges)

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/header_footer.py

@@ -0,0 +1,270 @@
+# Copyright (c) 2010-2024 openpyxl
+
+# Simplified implementation of headers and footers: let worksheets have separate items
+
+import re
+from warnings import warn
+
+from openpyxl.descriptors import (
+    Alias,
+    Bool,
+    Strict,
+    String,
+    Integer,
+    MatchPattern,
+    Typed,
+)
+from openpyxl.descriptors.serialisable import Serialisable
+
+
+from openpyxl.xml.functions import Element
+from openpyxl.utils.escape import escape, unescape
+
+
+FONT_PATTERN = '&"(?P<font>.+)"'
+COLOR_PATTERN  = "&K(?P<color>[A-F0-9]{6})"
+SIZE_REGEX = r"&(?P<size>\d+\s?)"
+FORMAT_REGEX = re.compile("{0}|{1}|{2}".format(FONT_PATTERN, COLOR_PATTERN,
+                                               SIZE_REGEX)
+                          )
+
+def _split_string(text):
+    """
+    Split the combined (decoded) string into left, center and right parts
+
+    # See http://stackoverflow.com/questions/27711175/regex-with-multiple-optional-groups for discussion
+    """
+
+    ITEM_REGEX = re.compile("""
+    (&L(?P<left>.+?))?
+    (&C(?P<center>.+?))?
+    (&R(?P<right>.+?))?
+    $""", re.VERBOSE | re.DOTALL)
+
+    m = ITEM_REGEX.match(text)
+    try:
+        parts = m.groupdict()
+    except AttributeError:
+        warn("""Cannot parse header or footer so it will be ignored""")
+        parts = {'left':'', 'right':'', 'center':''}
+    return parts
+
+
+class _HeaderFooterPart(Strict):
+
+    """
+    Individual left/center/right header/footer part
+
+    Do not use directly.
+
+    Header & Footer ampersand codes:
+
+    * &A   Inserts the worksheet name
+    * &B   Toggles bold
+    * &D or &[Date]   Inserts the current date
+    * &E   Toggles double-underline
+    * &F or &[File]   Inserts the workbook name
+    * &I   Toggles italic
+    * &N or &[Pages]   Inserts the total page count
+    * &S   Toggles strikethrough
+    * &T   Inserts the current time
+    * &[Tab]   Inserts the worksheet name
+    * &U   Toggles underline
+    * &X   Toggles superscript
+    * &Y   Toggles subscript
+    * &P or &[Page]   Inserts the current page number
+    * &P+n   Inserts the page number incremented by n
+    * &P-n   Inserts the page number decremented by n
+    * &[Path]   Inserts the workbook path
+    * &&   Escapes the ampersand character
+    * &"fontname"   Selects the named font
+    * &nn   Selects the specified 2-digit font point size
+
+    Colours are in RGB Hex
+    """
+
+    text = String(allow_none=True)
+    font = String(allow_none=True)
+    size = Integer(allow_none=True)
+    RGB = ("^[A-Fa-f0-9]{6}$")
+    color = MatchPattern(allow_none=True, pattern=RGB)
+
+
+    def __init__(self, text=None, font=None, size=None, color=None):
+        self.text = text
+        self.font = font
+        self.size = size
+        self.color = color
+
+
+    def __str__(self):
+        """
+        Convert to Excel HeaderFooter miniformat minus position
+        """
+        fmt = []
+        if self.font:
+            fmt.append(u'&"{0}"'.format(self.font))
+        if self.size:
+            fmt.append("&{0} ".format(self.size))
+        if self.color:
+            fmt.append("&K{0}".format(self.color))
+        return u"".join(fmt + [self.text])
+
+    def __bool__(self):
+        return bool(self.text)
+
+
+
+    @classmethod
+    def from_str(cls, text):
+        """
+        Convert from miniformat to object
+        """
+        keys = ('font', 'color', 'size')
+        kw = dict((k, v) for match in FORMAT_REGEX.findall(text)
+                  for k, v in zip(keys, match) if v)
+
+        kw['text'] = FORMAT_REGEX.sub('', text)
+
+        return cls(**kw)
+
+
+class HeaderFooterItem(Strict):
+    """
+    Header or footer item
+
+    """
+
+    left = Typed(expected_type=_HeaderFooterPart)
+    center = Typed(expected_type=_HeaderFooterPart)
+    centre = Alias("center")
+    right = Typed(expected_type=_HeaderFooterPart)
+
+    __keys = ('L', 'C', 'R')
+
+
+    def __init__(self, left=None, right=None, center=None):
+        if left is None:
+            left = _HeaderFooterPart()
+        self.left = left
+        if center is None:
+            center = _HeaderFooterPart()
+        self.center = center
+        if right is None:
+            right = _HeaderFooterPart()
+        self.right = right
+
+
+    def __str__(self):
+        """
+        Pack parts into a single string
+        """
+        TRANSFORM = {'&[Tab]': '&A', '&[Pages]': '&N', '&[Date]': '&D',
+                     '&[Path]': '&Z', '&[Page]': '&P', '&[Time]': '&T', '&[File]': '&F',
+                     '&[Picture]': '&G'}
+
+        # escape keys and create regex
+        SUBS_REGEX = re.compile("|".join(["({0})".format(re.escape(k))
+                                          for k in TRANSFORM]))
+
+        def replace(match):
+            """
+            Callback for re.sub
+            Replace expanded control with mini-format equivalent
+            """
+            sub = match.group(0)
+            return TRANSFORM[sub]
+
+        txt = []
+        for key, part in zip(
+            self.__keys, [self.left, self.center, self.right]):
+            if part.text is not None:
+                txt.append(u"&{0}{1}".format(key, str(part)))
+        txt = "".join(txt)
+        txt = SUBS_REGEX.sub(replace, txt)
+        return escape(txt)
+
+
+    def __bool__(self):
+        return any([self.left, self.center, self.right])
+
+
+
+    def to_tree(self, tagname):
+        """
+        Return as XML node
+        """
+        el = Element(tagname)
+        el.text = str(self)
+        return el
+
+
+    @classmethod
+    def from_tree(cls, node):
+        if node.text:
+            text = unescape(node.text)
+            parts = _split_string(text)
+            for k, v in parts.items():
+                if v is not None:
+                    parts[k] = _HeaderFooterPart.from_str(v)
+            self = cls(**parts)
+            return self
+
+
+class HeaderFooter(Serialisable):
+
+    tagname = "headerFooter"
+
+    differentOddEven = Bool(allow_none=True)
+    differentFirst = Bool(allow_none=True)
+    scaleWithDoc = Bool(allow_none=True)
+    alignWithMargins = Bool(allow_none=True)
+    oddHeader = Typed(expected_type=HeaderFooterItem, allow_none=True)
+    oddFooter = Typed(expected_type=HeaderFooterItem, allow_none=True)
+    evenHeader = Typed(expected_type=HeaderFooterItem, allow_none=True)
+    evenFooter = Typed(expected_type=HeaderFooterItem, allow_none=True)
+    firstHeader = Typed(expected_type=HeaderFooterItem, allow_none=True)
+    firstFooter = Typed(expected_type=HeaderFooterItem, allow_none=True)
+
+    __elements__ = ("oddHeader", "oddFooter", "evenHeader", "evenFooter", "firstHeader", "firstFooter")
+
+    def __init__(self,
+                 differentOddEven=None,
+                 differentFirst=None,
+                 scaleWithDoc=None,
+                 alignWithMargins=None,
+                 oddHeader=None,
+                 oddFooter=None,
+                 evenHeader=None,
+                 evenFooter=None,
+                 firstHeader=None,
+                 firstFooter=None,
+                ):
+        self.differentOddEven = differentOddEven
+        self.differentFirst = differentFirst
+        self.scaleWithDoc = scaleWithDoc
+        self.alignWithMargins = alignWithMargins
+        if oddHeader is None:
+            oddHeader = HeaderFooterItem()
+        self.oddHeader = oddHeader
+        if oddFooter is None:
+            oddFooter = HeaderFooterItem()
+        self.oddFooter = oddFooter
+        if evenHeader is None:
+            evenHeader = HeaderFooterItem()
+        self.evenHeader = evenHeader
+        if evenFooter is None:
+            evenFooter = HeaderFooterItem()
+        self.evenFooter = evenFooter
+        if firstHeader is None:
+            firstHeader = HeaderFooterItem()
+        self.firstHeader = firstHeader
+        if firstFooter is None:
+            firstFooter = HeaderFooterItem()
+        self.firstFooter = firstFooter
+
+
+    def __bool__(self):
+        parts = [getattr(self, attr) for attr in self.__attrs__ + self.__elements__]
+        return any(parts)
+

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/ole.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.descriptors.serialisable import Serialisable
+from openpyxl.descriptors import (
+    Typed,
+    Integer,
+    String,
+    Set,
+    Bool,
+    Sequence,
+)
+
+from openpyxl.drawing.spreadsheet_drawing import AnchorMarker
+from openpyxl.xml.constants import SHEET_DRAWING_NS
+
+
+class ObjectAnchor(Serialisable):
+
+    tagname = "anchor"
+
+    _from = Typed(expected_type=AnchorMarker, namespace=SHEET_DRAWING_NS)
+    to = Typed(expected_type=AnchorMarker, namespace=SHEET_DRAWING_NS)
+    moveWithCells = Bool(allow_none=True)
+    sizeWithCells = Bool(allow_none=True)
+    z_order = Integer(allow_none=True, hyphenated=True)
+
+
+    def __init__(self,
+                 _from=None,
+                 to=None,
+                 moveWithCells=False,
+                 sizeWithCells=False,
+                 z_order=None,
+                ):
+        self._from = _from
+        self.to = to
+        self.moveWithCells = moveWithCells
+        self.sizeWithCells = sizeWithCells
+        self.z_order = z_order
+
+
+class ObjectPr(Serialisable):
+
+    tagname = "objectPr"
+
+    anchor = Typed(expected_type=ObjectAnchor, )
+    locked = Bool(allow_none=True)
+    defaultSize = Bool(allow_none=True)
+    _print = Bool(allow_none=True)
+    disabled = Bool(allow_none=True)
+    uiObject = Bool(allow_none=True)
+    autoFill = Bool(allow_none=True)
+    autoLine = Bool(allow_none=True)
+    autoPict = Bool(allow_none=True)
+    macro = String()
+    altText = String(allow_none=True)
+    dde = Bool(allow_none=True)
+
+    __elements__ = ('anchor',)
+
+    def __init__(self,
+                 anchor=None,
+                 locked=True,
+                 defaultSize=True,
+                 _print=True,
+                 disabled=False,
+                 uiObject=False,
+                 autoFill=True,
+                 autoLine=True,
+                 autoPict=True,
+                 macro=None,
+                 altText=None,
+                 dde=False,
+                ):
+        self.anchor = anchor
+        self.locked = locked
+        self.defaultSize = defaultSize
+        self._print = _print
+        self.disabled = disabled
+        self.uiObject = uiObject
+        self.autoFill = autoFill
+        self.autoLine = autoLine
+        self.autoPict = autoPict
+        self.macro = macro
+        self.altText = altText
+        self.dde = dde
+
+
+class OleObject(Serialisable):
+
+    tagname = "oleObject"
+
+    objectPr = Typed(expected_type=ObjectPr, allow_none=True)
+    progId = String(allow_none=True)
+    dvAspect = Set(values=(['DVASPECT_CONTENT', 'DVASPECT_ICON']))
+    link = String(allow_none=True)
+    oleUpdate = Set(values=(['OLEUPDATE_ALWAYS', 'OLEUPDATE_ONCALL']))
+    autoLoad = Bool(allow_none=True)
+    shapeId = Integer()
+
+    __elements__ = ('objectPr',)
+
+    def __init__(self,
+                 objectPr=None,
+                 progId=None,
+                 dvAspect='DVASPECT_CONTENT',
+                 link=None,
+                 oleUpdate=None,
+                 autoLoad=False,
+                 shapeId=None,
+                ):
+        self.objectPr = objectPr
+        self.progId = progId
+        self.dvAspect = dvAspect
+        self.link = link
+        self.oleUpdate = oleUpdate
+        self.autoLoad = autoLoad
+        self.shapeId = shapeId
+
+
+class OleObjects(Serialisable):
+
+    tagname = "oleObjects"
+
+    oleObject = Sequence(expected_type=OleObject)
+
+    __elements__ = ('oleObject',)
+
+    def __init__(self,
+                 oleObject=(),
+                ):
+        self.oleObject = oleObject
+

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/picture.py

@@ -0,0 +1,8 @@
+#Autogenerated schema
+from openpyxl.descriptors.serialisable import Serialisable
+
+# same as related
+
+class SheetBackgroundPicture(Serialisable):
+
+    tagname = "sheetBackgroundPicture"

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/related.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.descriptors.serialisable import Serialisable
+from openpyxl.descriptors.excel import Relation
+
+
+class Related(Serialisable):
+
+    id = Relation()
+
+
+    def __init__(self, id=None):
+        self.id = id
+
+
+    def to_tree(self, tagname, idx=None):
+        return super().to_tree(tagname)

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/scenario.py

@@ -0,0 +1,105 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.descriptors.serialisable import Serialisable
+from openpyxl.descriptors import (
+    String,
+    Integer,
+    Bool,
+    Sequence,
+    Convertible,
+)
+from .cell_range import MultiCellRange
+
+
+class InputCells(Serialisable):
+
+    tagname = "inputCells"
+
+    r = String()
+    deleted = Bool(allow_none=True)
+    undone = Bool(allow_none=True)
+    val = String()
+    numFmtId = Integer(allow_none=True)
+
+    def __init__(self,
+                 r=None,
+                 deleted=False,
+                 undone=False,
+                 val=None,
+                 numFmtId=None,
+                ):
+        self.r = r
+        self.deleted = deleted
+        self.undone = undone
+        self.val = val
+        self.numFmtId = numFmtId
+
+
+class Scenario(Serialisable):
+
+    tagname = "scenario"
+
+    inputCells = Sequence(expected_type=InputCells)
+    name = String()
+    locked = Bool(allow_none=True)
+    hidden = Bool(allow_none=True)
+    user = String(allow_none=True)
+    comment = String(allow_none=True)
+
+    __elements__ = ('inputCells',)
+    __attrs__ = ('name', 'locked', 'hidden', 'user', 'comment', 'count')
+
+    def __init__(self,
+                 inputCells=(),
+                 name=None,
+                 locked=False,
+                 hidden=False,
+                 count=None,
+                 user=None,
+                 comment=None,
+                ):
+        self.inputCells = inputCells
+        self.name = name
+        self.locked = locked
+        self.hidden = hidden
+        self.user = user
+        self.comment = comment
+
+
+    @property
+    def count(self):
+        return len(self.inputCells)
+
+
+class ScenarioList(Serialisable):
+
+    tagname = "scenarios"
+
+    scenario = Sequence(expected_type=Scenario)
+    current = Integer(allow_none=True)
+    show = Integer(allow_none=True)
+    sqref = Convertible(expected_type=MultiCellRange, allow_none=True)
+
+    __elements__ = ('scenario',)
+
+    def __init__(self,
+                 scenario=(),
+                 current=None,
+                 show=None,
+                 sqref=None,
+                ):
+        self.scenario = scenario
+        self.current = current
+        self.show = show
+        self.sqref = sqref
+
+
+    def append(self, scenario):
+        s = self.scenario
+        s.append(scenario)
+        self.scenario = s
+
+
+    def __bool__(self):
+        return bool(self.scenario)
+

evalkit_tf437/lib/python3.10/site-packages/openpyxl/worksheet/views.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2010-2024 openpyxl
+
+from openpyxl.descriptors import (
+    Bool,
+    Integer,
+    String,
+    Set,
+    Float,
+    Typed,
+    NoneSet,
+    Sequence,
+)
+from openpyxl.descriptors.excel import ExtensionList
+from openpyxl.descriptors.serialisable import Serialisable
+
+
+class Pane(Serialisable):
+    xSplit = Float(allow_none=True)
+    ySplit = Float(allow_none=True)
+    topLeftCell = String(allow_none=True)
+    activePane = Set(values=("bottomRight", "topRight", "bottomLeft", "topLeft"))
+    state = Set(values=("split", "frozen", "frozenSplit"))
+
+    def __init__(self,
+                 xSplit=None,
+                 ySplit=None,
+                 topLeftCell=None,
+                 activePane="topLeft",
+                 state="split"):
+        self.xSplit = xSplit
+        self.ySplit = ySplit
+        self.topLeftCell = topLeftCell
+        self.activePane = activePane
+        self.state = state
+
+
+class Selection(Serialisable):
+    pane = NoneSet(values=("bottomRight", "topRight", "bottomLeft", "topLeft"))
+    activeCell = String(allow_none=True)
+    activeCellId = Integer(allow_none=True)
+    sqref = String(allow_none=True)
+
+    def __init__(self,
+                 pane=None,
+                 activeCell="A1",
+                 activeCellId=None,
+                 sqref="A1"):
+        self.pane = pane
+        self.activeCell = activeCell
+        self.activeCellId = activeCellId
+        self.sqref = sqref
+
+
+class SheetView(Serialisable):
+
+    """Information about the visible portions of this sheet."""
+
+    tagname = "sheetView"
+
+    windowProtection = Bool(allow_none=True)
+    showFormulas = Bool(allow_none=True)
+    showGridLines = Bool(allow_none=True)
+    showRowColHeaders = Bool(allow_none=True)
+    showZeros = Bool(allow_none=True)
+    rightToLeft = Bool(allow_none=True)
+    tabSelected = Bool(allow_none=True)
+    showRuler = Bool(allow_none=True)
+    showOutlineSymbols = Bool(allow_none=True)
+    defaultGridColor = Bool(allow_none=True)
+    showWhiteSpace = Bool(allow_none=True)
+    view = NoneSet(values=("normal", "pageBreakPreview", "pageLayout"))
+    topLeftCell = String(allow_none=True)
+    colorId = Integer(allow_none=True)
+    zoomScale = Integer(allow_none=True)
+    zoomScaleNormal = Integer(allow_none=True)
+    zoomScaleSheetLayoutView = Integer(allow_none=True)
+    zoomScalePageLayoutView = Integer(allow_none=True)
+    zoomToFit = Bool(allow_none=True) # Chart sheets only
+    workbookViewId = Integer()
+    selection = Sequence(expected_type=Selection)
+    pane = Typed(expected_type=Pane, allow_none=True)
+
+    def __init__(self,
+                 windowProtection=None,
+                 showFormulas=None,
+                 showGridLines=None,
+                 showRowColHeaders=None,
+                 showZeros=None,
+                 rightToLeft=None,
+                 tabSelected=None,
+                 showRuler=None,
+                 showOutlineSymbols=None,
+                 defaultGridColor=None,
+                 showWhiteSpace=None,
+                 view=None,
+                 topLeftCell=None,
+                 colorId=None,
+                 zoomScale=None,
+                 zoomScaleNormal=None,
+                 zoomScaleSheetLayoutView=None,
+                 zoomScalePageLayoutView=None,
+                 zoomToFit=None,
+                 workbookViewId=0,
+                 selection=None,
+                 pane=None,):
+        self.windowProtection = windowProtection
+        self.showFormulas = showFormulas
+        self.showGridLines = showGridLines
+        self.showRowColHeaders = showRowColHeaders
+        self.showZeros = showZeros
+        self.rightToLeft = rightToLeft
+        self.tabSelected = tabSelected
+        self.showRuler = showRuler
+        self.showOutlineSymbols = showOutlineSymbols
+        self.defaultGridColor = defaultGridColor
+        self.showWhiteSpace = showWhiteSpace
+        self.view = view
+        self.topLeftCell = topLeftCell
+        self.colorId = colorId
+        self.zoomScale = zoomScale
+        self.zoomScaleNormal = zoomScaleNormal
+        self.zoomScaleSheetLayoutView = zoomScaleSheetLayoutView
+        self.zoomScalePageLayoutView = zoomScalePageLayoutView
+        self.zoomToFit = zoomToFit
+        self.workbookViewId = workbookViewId
+        self.pane = pane
+        if selection is None:
+            selection = (Selection(), )
+        self.selection = selection
+
+
+class SheetViewList(Serialisable):
+
+    tagname = "sheetViews"
+
+    sheetView = Sequence(expected_type=SheetView, )
+    extLst = Typed(expected_type=ExtensionList, allow_none=True)
+
+    __elements__ = ('sheetView',)
+
+    def __init__(self,
+                 sheetView=None,
+                 extLst=None,
+                ):
+        if sheetView is None:
+            sheetView = [SheetView()]
+        self.sheetView = sheetView
+
+
+    @property
+    def active(self):
+        """
+        Returns the first sheet view which is assumed to be active
+        """
+        return self.sheetView[0]

evalkit_tf437/lib/python3.10/site-packages/pydub-0.25.1.dist-info/AUTHORS

@@ -0,0 +1,98 @@
+James Robert
+    github: jiaaro
+    twitter: @jiaaro
+    web: jiaaro.com
+    email: [email protected]
+
+Marc Webbie
+    github: marcwebbie
+
+Jean-philippe Serafin
+    github: jeanphix
+
+Anurag Ramdasan
+    github: AnuragRamdasan
+
+Choongmin Lee
+    github: clee704
+
+Patrick Pittman
+    github: ptpittman
+
+Hunter Lang
+    github: hunterlang
+
+Alexey
+    github: nihisil
+
+Jaymz Campbell
+    github: jaymzcd
+
+Ross McFarland
+    github: ross
+
+John McMellen
+    github: jmcmellen
+
+Johan Lövgren
+    github: dashj
+
+Joachim Krüger
+    github: jkrgr
+
+Shichao An
+    github: shichao-an
+
+Michael Bortnyck
+    github: mbortnyck
+
+André Cloete
+    github: aj-cloete
+
+David Acacio
+    github: dacacioa
+
+Thiago Abdnur
+    github: bolaum
+
+Aurélien Ooms
+    github: aureooms
+
+Mike Mattozzi
+    github: mmattozzi
+
+Marcio Mazza
+    github: marciomazza
+
+Sungsu Lim
+    github: proflim
+
+Evandro Myller
+    github: emyller
+
+Sérgio Agostinho
+    github: SergioRAgostinho
+
+Antonio Larrosa
+    github: antlarr
+
+Aaron Craig
+    github: craigthelinguist
+
+Carlos del Castillo
+    github: greyalien502
+
+Yudong Sun
+    github: sunjerry019
+
+Jorge Perianez
+    github: JPery
+
+Chendi Luo
+    github: Creonalia
+
+Daniel Lefevre
+    gitHub: dplefevre
+
+Grzegorz Kotfis
+    github: gkotfis

evalkit_tf437/lib/python3.10/site-packages/pydub-0.25.1.dist-info/INSTALLER

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

evalkit_tf437/lib/python3.10/site-packages/pydub-0.25.1.dist-info/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 James Robert, http://jiaaro.com
+
+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.

evalkit_tf437/lib/python3.10/site-packages/pydub-0.25.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+pydub-0.25.1.dist-info/AUTHORS,sha256=AyY2PS9I2enOyBnUnxcpeAX-NnMNWLQT4yDtg8IIy78,1250
+pydub-0.25.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pydub-0.25.1.dist-info/LICENSE,sha256=roVlNiJMx6OJ6Wh3H8XyWYFL3Q2mNTnPcigq2672iXo,1074
+pydub-0.25.1.dist-info/METADATA,sha256=f0M8_ZVtbiYoUI9ejXIeJ03Jo9A5Nbi-0V1bVqs5iYk,1406
+pydub-0.25.1.dist-info/RECORD,,
+pydub-0.25.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pydub-0.25.1.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+pydub-0.25.1.dist-info/top_level.txt,sha256=PHhiDCQVZdycZxfKL2lQozruBT6ZhvyZAwqjRrw3t0w,6
+pydub/__init__.py,sha256=w1Xv1awbaR3fMhTNE1-grnfswgARTNQrKpBzfZ--VBA,39
+pydub/__pycache__/__init__.cpython-310.pyc,,
+pydub/__pycache__/audio_segment.cpython-310.pyc,,
+pydub/__pycache__/effects.cpython-310.pyc,,
+pydub/__pycache__/exceptions.cpython-310.pyc,,
+pydub/__pycache__/generators.cpython-310.pyc,,
+pydub/__pycache__/logging_utils.cpython-310.pyc,,
+pydub/__pycache__/playback.cpython-310.pyc,,
+pydub/__pycache__/pyaudioop.cpython-310.pyc,,
+pydub/__pycache__/scipy_effects.cpython-310.pyc,,
+pydub/__pycache__/silence.cpython-310.pyc,,
+pydub/__pycache__/utils.cpython-310.pyc,,
+pydub/audio_segment.py,sha256=Nf5VkHGY1v9Jqb7NtEYfwRpLrfqusfBdPGOZsi7R5Cg,49185
+pydub/effects.py,sha256=1HUMzhefrwG_E1rTnzvbl-P0-KNuwHklCnu8QCGS7jA,11507
+pydub/exceptions.py,sha256=osgXoUujwpH8K6hr80iYpW30CMBDFwqyaRD-5d7ZpKs,455
+pydub/generators.py,sha256=u6q7J8JLOY-uEZqMPUTzakxyua3XNQcPiDsuiK2-lLA,4045
+pydub/logging_utils.py,sha256=WuSqfzn4zyT7PxXHGV-PXMDynufeM6sC6eSmVlGX2RU,374
+pydub/playback.py,sha256=zFngVclUL_7oDipjzKC8b7jToPNV11DV28rGyH8pio0,1987
+pydub/pyaudioop.py,sha256=Dp_cQgAyYjD4OV2ZHuxtKI2KABuPi9YYNRUF8giR80Q,13094
+pydub/scipy_effects.py,sha256=U2p8AQuVreTp5MrtUAzRbWgOHUc6Dwq0TAG_RtEg-7g,6637
+pydub/silence.py,sha256=F6MV0VlaO6mtuisjLGks_UR-GVmzO1v87_NKvzwRc30,6457
+pydub/utils.py,sha256=W71pgJFbbNP3adH63yn0Eo0CLLVgzXG7WHYSXpWvdyc,12368

evalkit_tf437/lib/python3.10/site-packages/sniffio-1.3.1.dist-info/LICENSE.APACHE2

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

evalkit_tf437/lib/python3.10/site-packages/sniffio-1.3.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+sniffio-1.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+sniffio-1.3.1.dist-info/LICENSE,sha256=ZSyHhIjRRWNh4Iw_hgf9e6WYkqFBA9Fczk_5PIW1zIs,185
+sniffio-1.3.1.dist-info/LICENSE.APACHE2,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+sniffio-1.3.1.dist-info/LICENSE.MIT,sha256=Pm2uVV65J4f8gtHUg1Vnf0VMf2Wus40_nnK_mj2vA0s,1046
+sniffio-1.3.1.dist-info/METADATA,sha256=CzGLVwmO3sz1heYKiJprantcQIbzqapi7_dqHTzuEtk,3875
+sniffio-1.3.1.dist-info/RECORD,,
+sniffio-1.3.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sniffio-1.3.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+sniffio-1.3.1.dist-info/top_level.txt,sha256=v9UJXGs5CyddCVeAqXkQiWOrpp6Wtx6GeRrPt9-jjHg,8
+sniffio/__init__.py,sha256=9WJEJlXu7yluP0YtI5SQ9M9OTQfbNHkadarK1vXGDPM,335
+sniffio/__pycache__/__init__.cpython-310.pyc,,
+sniffio/__pycache__/_impl.cpython-310.pyc,,
+sniffio/__pycache__/_version.cpython-310.pyc,,
+sniffio/_impl.py,sha256=UmUFMZpiuOrcjnuHhuYiYMxeCNWfqu9kBlaPf0xk6X8,2843
+sniffio/_tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sniffio/_tests/__pycache__/__init__.cpython-310.pyc,,
+sniffio/_tests/__pycache__/test_sniffio.cpython-310.pyc,,
+sniffio/_tests/test_sniffio.py,sha256=MMJZZJjQrUi95RANNM-a_55BZquA_gv4rHU1pevcTCM,2058
+sniffio/_version.py,sha256=iVes5xwsHeRzQDexBaAhyx_taNt2ucfA7CWAo4QDt6Q,89
+sniffio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

evalkit_tf437/lib/python3.10/site-packages/tomlkit/__init__.py

@@ -0,0 +1,59 @@
+from tomlkit.api import TOMLDocument
+from tomlkit.api import aot
+from tomlkit.api import array
+from tomlkit.api import boolean
+from tomlkit.api import comment
+from tomlkit.api import date
+from tomlkit.api import datetime
+from tomlkit.api import document
+from tomlkit.api import dump
+from tomlkit.api import dumps
+from tomlkit.api import float_
+from tomlkit.api import inline_table
+from tomlkit.api import integer
+from tomlkit.api import item
+from tomlkit.api import key
+from tomlkit.api import key_value
+from tomlkit.api import load
+from tomlkit.api import loads
+from tomlkit.api import nl
+from tomlkit.api import parse
+from tomlkit.api import register_encoder
+from tomlkit.api import string
+from tomlkit.api import table
+from tomlkit.api import time
+from tomlkit.api import unregister_encoder
+from tomlkit.api import value
+from tomlkit.api import ws
+
+
+__version__ = "0.12.0"
+__all__ = [
+    "aot",
+    "array",
+    "boolean",
+    "comment",
+    "date",
+    "datetime",
+    "document",
+    "dump",
+    "dumps",
+    "float_",
+    "inline_table",
+    "integer",
+    "item",
+    "key",
+    "key_value",
+    "load",
+    "loads",
+    "nl",
+    "parse",
+    "string",
+    "table",
+    "time",
+    "TOMLDocument",
+    "value",
+    "ws",
+    "register_encoder",
+    "unregister_encoder",
+]

evalkit_tf437/lib/python3.10/site-packages/tomlkit/_compat.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import contextlib
+import sys
+
+from typing import Any
+
+
+PY38 = sys.version_info >= (3, 8)
+
+
+def decode(string: Any, encodings: list[str] | None = None):
+    if not isinstance(string, bytes):
+        return string
+
+    encodings = encodings or ["utf-8", "latin1", "ascii"]
+
+    for encoding in encodings:
+        with contextlib.suppress(UnicodeEncodeError, UnicodeDecodeError):
+            return string.decode(encoding)
+
+    return string.decode(encodings[0], errors="ignore")

evalkit_tf437/lib/python3.10/site-packages/tomlkit/_utils.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import re
+
+from collections.abc import Mapping
+from datetime import date
+from datetime import datetime
+from datetime import time
+from datetime import timedelta
+from datetime import timezone
+from typing import Collection
+
+from tomlkit._compat import decode
+
+
+RFC_3339_LOOSE = re.compile(
+    "^"
+    r"(([0-9]+)-(\d{2})-(\d{2}))?"  # Date
+    "("
+    "([Tt ])?"  # Separator
+    r"(\d{2}):(\d{2}):(\d{2})(\.([0-9]+))?"  # Time
+    r"(([Zz])|([\+|\-]([01][0-9]|2[0-3]):([0-5][0-9])))?"  # Timezone
+    ")?"
+    "$"
+)
+
+RFC_3339_DATETIME = re.compile(
+    "^"
+    "([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])"  # Date
+    "[Tt ]"  # Separator
+    r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.([0-9]+))?"  # Time
+    r"(([Zz])|([\+|\-]([01][0-9]|2[0-3]):([0-5][0-9])))?"  # Timezone
+    "$"
+)
+
+RFC_3339_DATE = re.compile("^([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$")
+
+RFC_3339_TIME = re.compile(
+    r"^([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\.([0-9]+))?$"
+)
+
+_utc = timezone(timedelta(), "UTC")
+
+
+def parse_rfc3339(string: str) -> datetime | date | time:
+    m = RFC_3339_DATETIME.match(string)
+    if m:
+        year = int(m.group(1))
+        month = int(m.group(2))
+        day = int(m.group(3))
+        hour = int(m.group(4))
+        minute = int(m.group(5))
+        second = int(m.group(6))
+        microsecond = 0
+
+        if m.group(7):
+            microsecond = int((f"{m.group(8):<06s}")[:6])
+
+        if m.group(9):
+            # Timezone
+            tz = m.group(9)
+            if tz.upper() == "Z":
+                tzinfo = _utc
+            else:
+                sign = m.group(11)[0]
+                hour_offset, minute_offset = int(m.group(12)), int(m.group(13))
+                offset = timedelta(seconds=hour_offset * 3600 + minute_offset * 60)
+                if sign == "-":
+                    offset = -offset
+
+                tzinfo = timezone(offset, f"{sign}{m.group(12)}:{m.group(13)}")
+
+            return datetime(
+                year, month, day, hour, minute, second, microsecond, tzinfo=tzinfo
+            )
+        else:
+            return datetime(year, month, day, hour, minute, second, microsecond)
+
+    m = RFC_3339_DATE.match(string)
+    if m:
+        year = int(m.group(1))
+        month = int(m.group(2))
+        day = int(m.group(3))
+
+        return date(year, month, day)
+
+    m = RFC_3339_TIME.match(string)
+    if m:
+        hour = int(m.group(1))
+        minute = int(m.group(2))
+        second = int(m.group(3))
+        microsecond = 0
+
+        if m.group(4):
+            microsecond = int((f"{m.group(5):<06s}")[:6])
+
+        return time(hour, minute, second, microsecond)
+
+    raise ValueError("Invalid RFC 339 string")
+
+
+# https://toml.io/en/v1.0.0#string
+CONTROL_CHARS = frozenset(chr(c) for c in range(0x20)) | {chr(0x7F)}
+_escaped = {
+    "b": "\b",
+    "t": "\t",
+    "n": "\n",
+    "f": "\f",
+    "r": "\r",
+    '"': '"',
+    "\\": "\\",
+}
+_compact_escapes = {
+    **{v: f"\\{k}" for k, v in _escaped.items()},
+    '"""': '""\\"',
+}
+_basic_escapes = CONTROL_CHARS | {'"', "\\"}
+
+
+def _unicode_escape(seq: str) -> str:
+    return "".join(f"\\u{ord(c):04x}" for c in seq)
+
+
+def escape_string(s: str, escape_sequences: Collection[str] = _basic_escapes) -> str:
+    s = decode(s)
+
+    res = []
+    start = 0
+
+    def flush(inc=1):
+        if start != i:
+            res.append(s[start:i])
+
+        return i + inc
+
+    found_sequences = {seq for seq in escape_sequences if seq in s}
+
+    i = 0
+    while i < len(s):
+        for seq in found_sequences:
+            seq_len = len(seq)
+            if s[i:].startswith(seq):
+                start = flush(seq_len)
+                res.append(_compact_escapes.get(seq) or _unicode_escape(seq))
+                i += seq_len - 1  # fast-forward escape sequence
+        i += 1
+
+    flush()
+
+    return "".join(res)
+
+
+def merge_dicts(d1: dict, d2: dict) -> dict:
+    for k, v in d2.items():
+        if k in d1 and isinstance(d1[k], dict) and isinstance(v, Mapping):
+            merge_dicts(d1[k], v)
+        else:
+            d1[k] = d2[k]

evalkit_tf437/lib/python3.10/site-packages/tomlkit/api.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import contextlib
+import datetime as _datetime
+
+from collections.abc import Mapping
+from typing import IO
+from typing import Iterable
+from typing import TypeVar
+
+from tomlkit._utils import parse_rfc3339
+from tomlkit.container import Container
+from tomlkit.exceptions import UnexpectedCharError
+from tomlkit.items import CUSTOM_ENCODERS
+from tomlkit.items import AoT
+from tomlkit.items import Array
+from tomlkit.items import Bool
+from tomlkit.items import Comment
+from tomlkit.items import Date
+from tomlkit.items import DateTime
+from tomlkit.items import DottedKey
+from tomlkit.items import Encoder
+from tomlkit.items import Float
+from tomlkit.items import InlineTable
+from tomlkit.items import Integer
+from tomlkit.items import Item as _Item
+from tomlkit.items import Key
+from tomlkit.items import SingleKey
+from tomlkit.items import String
+from tomlkit.items import StringType as _StringType
+from tomlkit.items import Table
+from tomlkit.items import Time
+from tomlkit.items import Trivia
+from tomlkit.items import Whitespace
+from tomlkit.items import item
+from tomlkit.parser import Parser
+from tomlkit.toml_document import TOMLDocument
+
+
+def loads(string: str | bytes) -> TOMLDocument:
+    """
+    Parses a string into a TOMLDocument.
+
+    Alias for parse().
+    """
+    return parse(string)
+
+
+def dumps(data: Mapping, sort_keys: bool = False) -> str:
+    """
+    Dumps a TOMLDocument into a string.
+    """
+    if not isinstance(data, Container) and isinstance(data, Mapping):
+        data = item(dict(data), _sort_keys=sort_keys)
+
+    try:
+        # data should be a `Container` (and therefore implement `as_string`)
+        # for all type safe invocations of this function
+        return data.as_string()  # type: ignore[attr-defined]
+    except AttributeError as ex:
+        msg = f"Expecting Mapping or TOML Container, {type(data)} given"
+        raise TypeError(msg) from ex
+
+
+def load(fp: IO[str] | IO[bytes]) -> TOMLDocument:
+    """
+    Load toml document from a file-like object.
+    """
+    return parse(fp.read())
+
+
+def dump(data: Mapping, fp: IO[str], *, sort_keys: bool = False) -> None:
+    """
+    Dump a TOMLDocument into a writable file stream.
+
+    :param data: a dict-like object to dump
+    :param sort_keys: if true, sort the keys in alphabetic order
+    """
+    fp.write(dumps(data, sort_keys=sort_keys))
+
+
+def parse(string: str | bytes) -> TOMLDocument:
+    """
+    Parses a string or bytes into a TOMLDocument.
+    """
+    return Parser(string).parse()
+
+
+def document() -> TOMLDocument:
+    """
+    Returns a new TOMLDocument instance.
+    """
+    return TOMLDocument()
+
+
+# Items
+def integer(raw: str | int) -> Integer:
+    """Create an integer item from a number or string."""
+    return item(int(raw))
+
+
+def float_(raw: str | float) -> Float:
+    """Create an float item from a number or string."""
+    return item(float(raw))
+
+
+def boolean(raw: str) -> Bool:
+    """Turn `true` or `false` into a boolean item."""
+    return item(raw == "true")
+
+
+def string(
+    raw: str,
+    *,
+    literal: bool = False,
+    multiline: bool = False,
+    escape: bool = True,
+) -> String:
+    """Create a string item.
+
+    By default, this function will create *single line basic* strings, but
+    boolean flags (e.g. ``literal=True`` and/or ``multiline=True``)
+    can be used for personalization.
+
+    For more information, please check the spec: `<https://toml.io/en/v1.0.0#string>`__.
+
+    Common escaping rules will be applied for basic strings.
+    This can be controlled by explicitly setting ``escape=False``.
+    Please note that, if you disable escaping, you will have to make sure that
+    the given strings don't contain any forbidden character or sequence.
+    """
+    type_ = _StringType.select(literal, multiline)
+    return String.from_raw(raw, type_, escape)
+
+
+def date(raw: str) -> Date:
+    """Create a TOML date."""
+    value = parse_rfc3339(raw)
+    if not isinstance(value, _datetime.date):
+        raise ValueError("date() only accepts date strings.")
+
+    return item(value)
+
+
+def time(raw: str) -> Time:
+    """Create a TOML time."""
+    value = parse_rfc3339(raw)
+    if not isinstance(value, _datetime.time):
+        raise ValueError("time() only accepts time strings.")
+
+    return item(value)
+
+
+def datetime(raw: str) -> DateTime:
+    """Create a TOML datetime."""
+    value = parse_rfc3339(raw)
+    if not isinstance(value, _datetime.datetime):
+        raise ValueError("datetime() only accepts datetime strings.")
+
+    return item(value)
+
+
+def array(raw: str = None) -> Array:
+    """Create an array item for its string representation.
+
+    :Example:
+
+    >>> array("[1, 2, 3]")  # Create from a string
+    [1, 2, 3]
+    >>> a = array()
+    >>> a.extend([1, 2, 3])  # Create from a list
+    >>> a
+    [1, 2, 3]
+    """
+    if raw is None:
+        raw = "[]"
+
+    return value(raw)
+
+
+def table(is_super_table: bool | None = None) -> Table:
+    """Create an empty table.
+
+    :param is_super_table: if true, the table is a super table
+
+    :Example:
+
+    >>> doc = document()
+    >>> foo = table(True)
+    >>> bar = table()
+    >>> bar.update({'x': 1})
+    >>> foo.append('bar', bar)
+    >>> doc.append('foo', foo)
+    >>> print(doc.as_string())
+    [foo.bar]
+    x = 1
+    """
+    return Table(Container(), Trivia(), False, is_super_table)
+
+
+def inline_table() -> InlineTable:
+    """Create an inline table.
+
+    :Example:
+
+    >>> table = inline_table()
+    >>> table.update({'x': 1, 'y': 2})
+    >>> print(table.as_string())
+    {x = 1, y = 2}
+    """
+    return InlineTable(Container(), Trivia(), new=True)
+
+
+def aot() -> AoT:
+    """Create an array of table.
+
+    :Example:
+
+    >>> doc = document()
+    >>> aot = aot()
+    >>> aot.append(item({'x': 1}))
+    >>> doc.append('foo', aot)
+    >>> print(doc.as_string())
+    [[foo]]
+    x = 1
+    """
+    return AoT([])
+
+
+def key(k: str | Iterable[str]) -> Key:
+    """Create a key from a string. When a list of string is given,
+    it will create a dotted key.
+
+    :Example:
+
+    >>> doc = document()
+    >>> doc.append(key('foo'), 1)
+    >>> doc.append(key(['bar', 'baz']), 2)
+    >>> print(doc.as_string())
+    foo = 1
+    bar.baz = 2
+    """
+    if isinstance(k, str):
+        return SingleKey(k)
+    return DottedKey([key(_k) for _k in k])
+
+
+def value(raw: str) -> _Item:
+    """Parse a simple value from a string.
+
+    :Example:
+
+    >>> value("1")
+    1
+    >>> value("true")
+    True
+    >>> value("[1, 2, 3]")
+    [1, 2, 3]
+    """
+    parser = Parser(raw)
+    v = parser._parse_value()
+    if not parser.end():
+        raise parser.parse_error(UnexpectedCharError, char=parser._current)
+    return v
+
+
+def key_value(src: str) -> tuple[Key, _Item]:
+    """Parse a key-value pair from a string.
+
+    :Example:
+
+    >>> key_value("foo = 1")
+    (Key('foo'), 1)
+    """
+    return Parser(src)._parse_key_value()
+
+
+def ws(src: str) -> Whitespace:
+    """Create a whitespace from a string."""
+    return Whitespace(src, fixed=True)
+
+
+def nl() -> Whitespace:
+    """Create a newline item."""
+    return ws("\n")
+
+
+def comment(string: str) -> Comment:
+    """Create a comment item."""
+    return Comment(Trivia(comment_ws="  ", comment="# " + string))
+
+
+E = TypeVar("E", bound=Encoder)
+
+
+def register_encoder(encoder: E) -> E:
+    """Add a custom encoder, which should be a function that will be called
+    if the value can't otherwise be converted. It should takes a single value
+    and return a TOMLKit item or raise a ``TypeError``.
+    """
+    CUSTOM_ENCODERS.append(encoder)
+    return encoder
+
+
+def unregister_encoder(encoder: Encoder) -> None:
+    """Unregister a custom encoder."""
+    with contextlib.suppress(ValueError):
+        CUSTOM_ENCODERS.remove(encoder)

evalkit_tf437/lib/python3.10/site-packages/tomlkit/container.py

@@ -0,0 +1,866 @@
+from __future__ import annotations
+
+import copy
+
+from typing import Any
+from typing import Iterator
+
+from tomlkit._compat import decode
+from tomlkit._types import _CustomDict
+from tomlkit._utils import merge_dicts
+from tomlkit.exceptions import KeyAlreadyPresent
+from tomlkit.exceptions import NonExistentKey
+from tomlkit.exceptions import TOMLKitError
+from tomlkit.items import AoT
+from tomlkit.items import Comment
+from tomlkit.items import Item
+from tomlkit.items import Key
+from tomlkit.items import Null
+from tomlkit.items import SingleKey
+from tomlkit.items import Table
+from tomlkit.items import Trivia
+from tomlkit.items import Whitespace
+from tomlkit.items import item as _item
+
+
+_NOT_SET = object()
+
+
+class Container(_CustomDict):
+    """
+    A container for items within a TOMLDocument.
+
+    This class implements the `dict` interface with copy/deepcopy protocol.
+    """
+
+    def __init__(self, parsed: bool = False) -> None:
+        self._map: dict[SingleKey, int | tuple[int, ...]] = {}
+        self._body: list[tuple[Key | None, Item]] = []
+        self._parsed = parsed
+        self._table_keys = []
+
+    @property
+    def body(self) -> list[tuple[Key | None, Item]]:
+        return self._body
+
+    def unwrap(self) -> dict[str, Any]:
+        unwrapped = {}
+        for k, v in self.items():
+            if k is None:
+                continue
+
+            if isinstance(k, Key):
+                k = k.key
+
+            if hasattr(v, "unwrap"):
+                v = v.unwrap()
+
+            if k in unwrapped:
+                merge_dicts(unwrapped[k], v)
+            else:
+                unwrapped[k] = v
+
+        return unwrapped
+
+    @property
+    def value(self) -> dict[str, Any]:
+        d = {}
+        for k, v in self._body:
+            if k is None:
+                continue
+
+            k = k.key
+            v = v.value
+
+            if isinstance(v, Container):
+                v = v.value
+
+            if k in d:
+                merge_dicts(d[k], v)
+            else:
+                d[k] = v
+
+        return d
+
+    def parsing(self, parsing: bool) -> None:
+        self._parsed = parsing
+
+        for _, v in self._body:
+            if isinstance(v, Table):
+                v.value.parsing(parsing)
+            elif isinstance(v, AoT):
+                for t in v.body:
+                    t.value.parsing(parsing)
+
+    def add(self, key: Key | Item | str, item: Item | None = None) -> Container:
+        """
+        Adds an item to the current Container.
+
+        :Example:
+
+        >>> # add a key-value pair
+        >>> doc.add('key', 'value')
+        >>> # add a comment or whitespace or newline
+        >>> doc.add(comment('# comment'))
+        """
+        if item is None:
+            if not isinstance(key, (Comment, Whitespace)):
+                raise ValueError(
+                    "Non comment/whitespace items must have an associated key"
+                )
+
+            key, item = None, key
+
+        return self.append(key, item)
+
+    def _handle_dotted_key(self, key: Key, value: Item) -> None:
+        if isinstance(value, (Table, AoT)):
+            raise TOMLKitError("Can't add a table to a dotted key")
+        name, *mid, last = key
+        name._dotted = True
+        table = current = Table(Container(True), Trivia(), False, is_super_table=True)
+        for _name in mid:
+            _name._dotted = True
+            new_table = Table(Container(True), Trivia(), False, is_super_table=True)
+            current.append(_name, new_table)
+            current = new_table
+
+        last.sep = key.sep
+        current.append(last, value)
+
+        self.append(name, table)
+        return
+
+    def _get_last_index_before_table(self) -> int:
+        last_index = -1
+        for i, (k, v) in enumerate(self._body):
+            if isinstance(v, Null):
+                continue  # Null elements are inserted after deletion
+
+            if isinstance(v, Whitespace) and not v.is_fixed():
+                continue
+
+            if isinstance(v, (Table, AoT)) and not k.is_dotted():
+                break
+            last_index = i
+        return last_index + 1
+
+    def append(self, key: Key | str | None, item: Item) -> Container:
+        """Similar to :meth:`add` but both key and value must be given."""
+        if not isinstance(key, Key) and key is not None:
+            key = SingleKey(key)
+
+        if not isinstance(item, Item):
+            item = _item(item)
+
+        if key is not None and key.is_multi():
+            self._handle_dotted_key(key, item)
+            return self
+
+        if isinstance(item, (AoT, Table)) and item.name is None:
+            item.name = key.key
+
+        prev = self._previous_item()
+        prev_ws = isinstance(prev, Whitespace) or ends_with_whitespace(prev)
+        if isinstance(item, Table):
+            if not self._parsed:
+                item.invalidate_display_name()
+            if (
+                self._body
+                and not (self._parsed or item.trivia.indent or prev_ws)
+                and not key.is_dotted()
+            ):
+                item.trivia.indent = "\n"
+
+        if isinstance(item, AoT) and self._body and not self._parsed:
+            item.invalidate_display_name()
+            if item and not ("\n" in item[0].trivia.indent or prev_ws):
+                item[0].trivia.indent = "\n" + item[0].trivia.indent
+
+        if key is not None and key in self:
+            current_idx = self._map[key]
+            if isinstance(current_idx, tuple):
+                current_body_element = self._body[current_idx[-1]]
+            else:
+                current_body_element = self._body[current_idx]
+
+            current = current_body_element[1]
+
+            if isinstance(item, Table):
+                if not isinstance(current, (Table, AoT)):
+                    raise KeyAlreadyPresent(key)
+
+                if item.is_aot_element():
+                    # New AoT element found later on
+                    # Adding it to the current AoT
+                    if not isinstance(current, AoT):
+                        current = AoT([current, item], parsed=self._parsed)
+
+                        self._replace(key, key, current)
+                    else:
+                        current.append(item)
+
+                    return self
+                elif current.is_aot():
+                    if not item.is_aot_element():
+                        # Tried to define a table after an AoT with the same name.
+                        raise KeyAlreadyPresent(key)
+
+                    current.append(item)
+
+                    return self
+                elif current.is_super_table():
+                    if item.is_super_table():
+                        # We need to merge both super tables
+                        if (
+                            self._table_keys[-1] != current_body_element[0]
+                            or key.is_dotted()
+                            or current_body_element[0].is_dotted()
+                        ):
+                            if key.is_dotted() and not self._parsed:
+                                idx = self._get_last_index_before_table()
+                            else:
+                                idx = len(self._body)
+
+                            if idx < len(self._body):
+                                self._insert_at(idx, key, item)
+                            else:
+                                self._raw_append(key, item)
+
+                            # Building a temporary proxy to check for errors
+                            OutOfOrderTableProxy(self, self._map[key])
+
+                            return self
+
+                        # Create a new element to replace the old one
+                        current = copy.deepcopy(current)
+                        for k, v in item.value.body:
+                            current.append(k, v)
+                        self._body[
+                            current_idx[-1]
+                            if isinstance(current_idx, tuple)
+                            else current_idx
+                        ] = (current_body_element[0], current)
+
+                        return self
+                    elif current_body_element[0].is_dotted():
+                        raise TOMLKitError("Redefinition of an existing table")
+                elif not item.is_super_table():
+                    raise KeyAlreadyPresent(key)
+            elif isinstance(item, AoT):
+                if not isinstance(current, AoT):
+                    # Tried to define an AoT after a table with the same name.
+                    raise KeyAlreadyPresent(key)
+
+                for table in item.body:
+                    current.append(table)
+
+                return self
+            else:
+                raise KeyAlreadyPresent(key)
+
+        is_table = isinstance(item, (Table, AoT))
+        if (
+            key is not None
+            and self._body
+            and not self._parsed
+            and (not is_table or key.is_dotted())
+        ):
+            # If there is already at least one table in the current container
+            # and the given item is not a table, we need to find the last
+            # item that is not a table and insert after it
+            # If no such item exists, insert at the top of the table
+            last_index = self._get_last_index_before_table()
+
+            if last_index < len(self._body):
+                return self._insert_at(last_index, key, item)
+            else:
+                previous_item = self._body[-1][1]
+                if not (
+                    isinstance(previous_item, Whitespace)
+                    or ends_with_whitespace(previous_item)
+                    or "\n" in previous_item.trivia.trail
+                ):
+                    previous_item.trivia.trail += "\n"
+
+        self._raw_append(key, item)
+        return self
+
+    def _raw_append(self, key: Key, item: Item) -> None:
+        if key in self._map:
+            current_idx = self._map[key]
+            if not isinstance(current_idx, tuple):
+                current_idx = (current_idx,)
+
+            current = self._body[current_idx[-1]][1]
+            if key is not None and not isinstance(current, Table):
+                raise KeyAlreadyPresent(key)
+
+            self._map[key] = current_idx + (len(self._body),)
+        else:
+            self._map[key] = len(self._body)
+
+        self._body.append((key, item))
+        if item.is_table():
+            self._table_keys.append(key)
+
+        if key is not None:
+            dict.__setitem__(self, key.key, item.value)
+
+        return self
+
+    def _remove_at(self, idx: int) -> None:
+        key = self._body[idx][0]
+        index = self._map.get(key)
+        if index is None:
+            raise NonExistentKey(key)
+        self._body[idx] = (None, Null())
+
+        if isinstance(index, tuple):
+            index = list(index)
+            index.remove(idx)
+            if len(index) == 1:
+                index = index.pop()
+            else:
+                index = tuple(index)
+            self._map[key] = index
+        else:
+            dict.__delitem__(self, key.key)
+            self._map.pop(key)
+
+    def remove(self, key: Key | str) -> Container:
+        """Remove a key from the container."""
+        if not isinstance(key, Key):
+            key = SingleKey(key)
+
+        idx = self._map.pop(key, None)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        if isinstance(idx, tuple):
+            for i in idx:
+                self._body[i] = (None, Null())
+        else:
+            self._body[idx] = (None, Null())
+
+        dict.__delitem__(self, key.key)
+
+        return self
+
+    def _insert_after(
+        self, key: Key | str, other_key: Key | str, item: Any
+    ) -> Container:
+        if key is None:
+            raise ValueError("Key cannot be null in insert_after()")
+
+        if key not in self:
+            raise NonExistentKey(key)
+
+        if not isinstance(key, Key):
+            key = SingleKey(key)
+
+        if not isinstance(other_key, Key):
+            other_key = SingleKey(other_key)
+
+        item = _item(item)
+
+        idx = self._map[key]
+        # Insert after the max index if there are many.
+        if isinstance(idx, tuple):
+            idx = max(idx)
+        current_item = self._body[idx][1]
+        if "\n" not in current_item.trivia.trail:
+            current_item.trivia.trail += "\n"
+
+        # Increment indices after the current index
+        for k, v in self._map.items():
+            if isinstance(v, tuple):
+                new_indices = []
+                for v_ in v:
+                    if v_ > idx:
+                        v_ = v_ + 1
+
+                    new_indices.append(v_)
+
+                self._map[k] = tuple(new_indices)
+            elif v > idx:
+                self._map[k] = v + 1
+
+        self._map[other_key] = idx + 1
+        self._body.insert(idx + 1, (other_key, item))
+
+        if key is not None:
+            dict.__setitem__(self, other_key.key, item.value)
+
+        return self
+
+    def _insert_at(self, idx: int, key: Key | str, item: Any) -> Container:
+        if idx > len(self._body) - 1:
+            raise ValueError(f"Unable to insert at position {idx}")
+
+        if not isinstance(key, Key):
+            key = SingleKey(key)
+
+        item = _item(item)
+
+        if idx > 0:
+            previous_item = self._body[idx - 1][1]
+            if not (
+                isinstance(previous_item, Whitespace)
+                or ends_with_whitespace(previous_item)
+                or isinstance(item, (AoT, Table))
+                or "\n" in previous_item.trivia.trail
+            ):
+                previous_item.trivia.trail += "\n"
+
+        # Increment indices after the current index
+        for k, v in self._map.items():
+            if isinstance(v, tuple):
+                new_indices = []
+                for v_ in v:
+                    if v_ >= idx:
+                        v_ = v_ + 1
+
+                    new_indices.append(v_)
+
+                self._map[k] = tuple(new_indices)
+            elif v >= idx:
+                self._map[k] = v + 1
+
+        if key in self._map:
+            current_idx = self._map[key]
+            if not isinstance(current_idx, tuple):
+                current_idx = (current_idx,)
+            self._map[key] = current_idx + (idx,)
+        else:
+            self._map[key] = idx
+        self._body.insert(idx, (key, item))
+
+        dict.__setitem__(self, key.key, item.value)
+
+        return self
+
+    def item(self, key: Key | str) -> Item:
+        """Get an item for the given key."""
+        if not isinstance(key, Key):
+            key = SingleKey(key)
+
+        idx = self._map.get(key)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        if isinstance(idx, tuple):
+            # The item we are getting is an out of order table
+            # so we need a proxy to retrieve the proper objects
+            # from the parent container
+            return OutOfOrderTableProxy(self, idx)
+
+        return self._body[idx][1]
+
+    def last_item(self) -> Item | None:
+        """Get the last item."""
+        if self._body:
+            return self._body[-1][1]
+
+    def as_string(self) -> str:
+        """Render as TOML string."""
+        s = ""
+        for k, v in self._body:
+            if k is not None:
+                if isinstance(v, Table):
+                    s += self._render_table(k, v)
+                elif isinstance(v, AoT):
+                    s += self._render_aot(k, v)
+                else:
+                    s += self._render_simple_item(k, v)
+            else:
+                s += self._render_simple_item(k, v)
+
+        return s
+
+    def _render_table(self, key: Key, table: Table, prefix: str | None = None) -> str:
+        cur = ""
+
+        if table.display_name is not None:
+            _key = table.display_name
+        else:
+            _key = key.as_string()
+
+            if prefix is not None:
+                _key = prefix + "." + _key
+
+        if not table.is_super_table() or (
+            any(
+                not isinstance(v, (Table, AoT, Whitespace, Null))
+                for _, v in table.value.body
+            )
+            and not key.is_dotted()
+        ):
+            open_, close = "[", "]"
+            if table.is_aot_element():
+                open_, close = "[[", "]]"
+
+            newline_in_table_trivia = (
+                "\n" if "\n" not in table.trivia.trail and len(table.value) > 0 else ""
+            )
+            cur += (
+                f"{table.trivia.indent}"
+                f"{open_}"
+                f"{decode(_key)}"
+                f"{close}"
+                f"{table.trivia.comment_ws}"
+                f"{decode(table.trivia.comment)}"
+                f"{table.trivia.trail}"
+                f"{newline_in_table_trivia}"
+            )
+        elif table.trivia.indent == "\n":
+            cur += table.trivia.indent
+
+        for k, v in table.value.body:
+            if isinstance(v, Table):
+                if v.is_super_table():
+                    if k.is_dotted() and not key.is_dotted():
+                        # Dotted key inside table
+                        cur += self._render_table(k, v)
+                    else:
+                        cur += self._render_table(k, v, prefix=_key)
+                else:
+                    cur += self._render_table(k, v, prefix=_key)
+            elif isinstance(v, AoT):
+                cur += self._render_aot(k, v, prefix=_key)
+            else:
+                cur += self._render_simple_item(
+                    k, v, prefix=_key if key.is_dotted() else None
+                )
+
+        return cur
+
+    def _render_aot(self, key, aot, prefix=None):
+        _key = key.as_string()
+        if prefix is not None:
+            _key = prefix + "." + _key
+
+        cur = ""
+        _key = decode(_key)
+        for table in aot.body:
+            cur += self._render_aot_table(table, prefix=_key)
+
+        return cur
+
+    def _render_aot_table(self, table: Table, prefix: str | None = None) -> str:
+        cur = ""
+        _key = prefix or ""
+        open_, close = "[[", "]]"
+
+        cur += (
+            f"{table.trivia.indent}"
+            f"{open_}"
+            f"{decode(_key)}"
+            f"{close}"
+            f"{table.trivia.comment_ws}"
+            f"{decode(table.trivia.comment)}"
+            f"{table.trivia.trail}"
+        )
+
+        for k, v in table.value.body:
+            if isinstance(v, Table):
+                if v.is_super_table():
+                    if k.is_dotted():
+                        # Dotted key inside table
+                        cur += self._render_table(k, v)
+                    else:
+                        cur += self._render_table(k, v, prefix=_key)
+                else:
+                    cur += self._render_table(k, v, prefix=_key)
+            elif isinstance(v, AoT):
+                cur += self._render_aot(k, v, prefix=_key)
+            else:
+                cur += self._render_simple_item(k, v)
+
+        return cur
+
+    def _render_simple_item(self, key, item, prefix=None):
+        if key is None:
+            return item.as_string()
+
+        _key = key.as_string()
+        if prefix is not None:
+            _key = prefix + "." + _key
+
+        return (
+            f"{item.trivia.indent}"
+            f"{decode(_key)}"
+            f"{key.sep}"
+            f"{decode(item.as_string())}"
+            f"{item.trivia.comment_ws}"
+            f"{decode(item.trivia.comment)}"
+            f"{item.trivia.trail}"
+        )
+
+    def __len__(self) -> int:
+        return dict.__len__(self)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(dict.keys(self))
+
+    # Dictionary methods
+    def __getitem__(self, key: Key | str) -> Item | Container:
+        if not isinstance(key, Key):
+            key = SingleKey(key)
+
+        idx = self._map.get(key)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        if isinstance(idx, tuple):
+            # The item we are getting is an out of order table
+            # so we need a proxy to retrieve the proper objects
+            # from the parent container
+            return OutOfOrderTableProxy(self, idx)
+
+        item = self._body[idx][1]
+        if item.is_boolean():
+            return item.value
+
+        return item
+
+    def __setitem__(self, key: Key | str, value: Any) -> None:
+        if key is not None and key in self:
+            old_key = next(filter(lambda k: k == key, self._map))
+            self._replace(old_key, key, value)
+        else:
+            self.append(key, value)
+
+    def __delitem__(self, key: Key | str) -> None:
+        self.remove(key)
+
+    def setdefault(self, key: Key | str, default: Any) -> Any:
+        super().setdefault(key, default=default)
+        return self[key]
+
+    def _replace(self, key: Key | str, new_key: Key | str, value: Item) -> None:
+        if not isinstance(key, Key):
+            key = SingleKey(key)
+
+        idx = self._map.get(key)
+        if idx is None:
+            raise NonExistentKey(key)
+
+        self._replace_at(idx, new_key, value)
+
+    def _replace_at(
+        self, idx: int | tuple[int], new_key: Key | str, value: Item
+    ) -> None:
+        value = _item(value)
+
+        if isinstance(idx, tuple):
+            for i in idx[1:]:
+                self._body[i] = (None, Null())
+
+            idx = idx[0]
+
+        k, v = self._body[idx]
+        if not isinstance(new_key, Key):
+            if (
+                isinstance(value, (AoT, Table)) != isinstance(v, (AoT, Table))
+                or new_key != k.key
+            ):
+                new_key = SingleKey(new_key)
+            else:  # Inherit the sep of the old key
+                new_key = k
+
+        del self._map[k]
+        self._map[new_key] = idx
+        if new_key != k:
+            dict.__delitem__(self, k)
+
+        if isinstance(value, (AoT, Table)) != isinstance(v, (AoT, Table)):
+            # new tables should appear after all non-table values
+            self.remove(k)
+            for i in range(idx, len(self._body)):
+                if isinstance(self._body[i][1], (AoT, Table)):
+                    self._insert_at(i, new_key, value)
+                    idx = i
+                    break
+            else:
+                idx = -1
+                self.append(new_key, value)
+        else:
+            # Copying trivia
+            if not isinstance(value, (Whitespace, AoT)):
+                value.trivia.indent = v.trivia.indent
+                value.trivia.comment_ws = value.trivia.comment_ws or v.trivia.comment_ws
+                value.trivia.comment = value.trivia.comment or v.trivia.comment
+                value.trivia.trail = v.trivia.trail
+            self._body[idx] = (new_key, value)
+
+        if hasattr(value, "invalidate_display_name"):
+            value.invalidate_display_name()  # type: ignore[attr-defined]
+
+        if isinstance(value, Table):
+            # Insert a cosmetic new line for tables if:
+            # - it does not have it yet OR is not followed by one
+            # - it is not the last item
+            last, _ = self._previous_item_with_index()
+            idx = last if idx < 0 else idx
+            has_ws = ends_with_whitespace(value)
+            next_ws = idx < last and isinstance(self._body[idx + 1][1], Whitespace)
+            if idx < last and not (next_ws or has_ws):
+                value.append(None, Whitespace("\n"))
+
+            dict.__setitem__(self, new_key.key, value.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __repr__(self) -> str:
+        return repr(self.value)
+
+    def __eq__(self, other: dict) -> bool:
+        if not isinstance(other, dict):
+            return NotImplemented
+
+        return self.value == other
+
+    def _getstate(self, protocol):
+        return (self._parsed,)
+
+    def __reduce__(self):
+        return self.__reduce_ex__(2)
+
+    def __reduce_ex__(self, protocol):
+        return (
+            self.__class__,
+            self._getstate(protocol),
+            (self._map, self._body, self._parsed, self._table_keys),
+        )
+
+    def __setstate__(self, state):
+        self._map = state[0]
+        self._body = state[1]
+        self._parsed = state[2]
+        self._table_keys = state[3]
+
+        for key, item in self._body:
+            if key is not None:
+                dict.__setitem__(self, key.key, item.value)
+
+    def copy(self) -> Container:
+        return copy.copy(self)
+
+    def __copy__(self) -> Container:
+        c = self.__class__(self._parsed)
+        for k, v in dict.items(self):
+            dict.__setitem__(c, k, v)
+
+        c._body += self.body
+        c._map.update(self._map)
+
+        return c
+
+    def _previous_item_with_index(
+        self, idx: int | None = None, ignore=(Null,)
+    ) -> tuple[int, Item] | None:
+        """Find the immediate previous item before index ``idx``"""
+        if idx is None or idx > len(self._body):
+            idx = len(self._body)
+        for i in range(idx - 1, -1, -1):
+            v = self._body[i][-1]
+            if not isinstance(v, ignore):
+                return i, v
+        return None
+
+    def _previous_item(self, idx: int | None = None, ignore=(Null,)) -> Item | None:
+        """Find the immediate previous item before index ``idx``.
+        If ``idx`` is not given, the last item is returned.
+        """
+        prev = self._previous_item_with_index(idx, ignore)
+        return prev[-1] if prev else None
+
+
+class OutOfOrderTableProxy(_CustomDict):
+    def __init__(self, container: Container, indices: tuple[int]) -> None:
+        self._container = container
+        self._internal_container = Container(True)
+        self._tables = []
+        self._tables_map = {}
+
+        for i in indices:
+            _, item = self._container._body[i]
+
+            if isinstance(item, Table):
+                self._tables.append(item)
+                table_idx = len(self._tables) - 1
+                for k, v in item.value.body:
+                    self._internal_container.append(k, v)
+                    self._tables_map[k] = table_idx
+                    if k is not None:
+                        dict.__setitem__(self, k.key, v)
+
+    def unwrap(self) -> str:
+        return self._internal_container.unwrap()
+
+    @property
+    def value(self):
+        return self._internal_container.value
+
+    def __getitem__(self, key: Key | str) -> Any:
+        if key not in self._internal_container:
+            raise NonExistentKey(key)
+
+        return self._internal_container[key]
+
+    def __setitem__(self, key: Key | str, item: Any) -> None:
+        if key in self._tables_map:
+            table = self._tables[self._tables_map[key]]
+            table[key] = item
+        elif self._tables:
+            table = self._tables[0]
+            table[key] = item
+        else:
+            self._container[key] = item
+
+        self._internal_container[key] = item
+        if key is not None:
+            dict.__setitem__(self, key, item)
+
+    def _remove_table(self, table: Table) -> None:
+        """Remove table from the parent container"""
+        self._tables.remove(table)
+        for idx, item in enumerate(self._container._body):
+            if item[1] is table:
+                self._container._remove_at(idx)
+                break
+
+    def __delitem__(self, key: Key | str) -> None:
+        if key in self._tables_map:
+            table = self._tables[self._tables_map[key]]
+            del table[key]
+            if not table and len(self._tables) > 1:
+                self._remove_table(table)
+            del self._tables_map[key]
+        else:
+            raise NonExistentKey(key)
+
+        del self._internal_container[key]
+        if key is not None:
+            dict.__delitem__(self, key)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(dict.keys(self))
+
+    def __len__(self) -> int:
+        return dict.__len__(self)
+
+    def setdefault(self, key: Key | str, default: Any) -> Any:
+        super().setdefault(key, default=default)
+        return self[key]
+
+
+def ends_with_whitespace(it: Any) -> bool:
+    """Returns ``True`` if the given item ``it`` is a ``Table`` or ``AoT`` object
+    ending with a ``Whitespace``.
+    """
+    return (
+        isinstance(it, Table) and isinstance(it.value._previous_item(), Whitespace)
+    ) or (isinstance(it, AoT) and len(it) > 0 and isinstance(it[-1], Whitespace))

evalkit_tf437/lib/python3.10/site-packages/tomlkit/exceptions.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+from typing import Collection
+
+
+class TOMLKitError(Exception):
+    pass
+
+
+class ParseError(ValueError, TOMLKitError):
+    """
+    This error occurs when the parser encounters a syntax error
+    in the TOML being parsed. The error references the line and
+    location within the line where the error was encountered.
+    """
+
+    def __init__(self, line: int, col: int, message: str | None = None) -> None:
+        self._line = line
+        self._col = col
+
+        if message is None:
+            message = "TOML parse error"
+
+        super().__init__(f"{message} at line {self._line} col {self._col}")
+
+    @property
+    def line(self):
+        return self._line
+
+    @property
+    def col(self):
+        return self._col
+
+
+class MixedArrayTypesError(ParseError):
+    """
+    An array was found that had two or more element types.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Mixed types found in array"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidNumberError(ParseError):
+    """
+    A numeric field was improperly specified.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Invalid number"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidDateTimeError(ParseError):
+    """
+    A datetime field was improperly specified.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Invalid datetime"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidDateError(ParseError):
+    """
+    A date field was improperly specified.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Invalid date"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidTimeError(ParseError):
+    """
+    A date field was improperly specified.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Invalid time"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidNumberOrDateError(ParseError):
+    """
+    A numeric or date field was improperly specified.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Invalid number or date format"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidUnicodeValueError(ParseError):
+    """
+    A unicode code was improperly specified.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Invalid unicode value"
+
+        super().__init__(line, col, message=message)
+
+
+class UnexpectedCharError(ParseError):
+    """
+    An unexpected character was found during parsing.
+    """
+
+    def __init__(self, line: int, col: int, char: str) -> None:
+        message = f"Unexpected character: {repr(char)}"
+
+        super().__init__(line, col, message=message)
+
+
+class EmptyKeyError(ParseError):
+    """
+    An empty key was found during parsing.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Empty key"
+
+        super().__init__(line, col, message=message)
+
+
+class EmptyTableNameError(ParseError):
+    """
+    An empty table name was found during parsing.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Empty table name"
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidCharInStringError(ParseError):
+    """
+    The string being parsed contains an invalid character.
+    """
+
+    def __init__(self, line: int, col: int, char: str) -> None:
+        message = f"Invalid character {repr(char)} in string"
+
+        super().__init__(line, col, message=message)
+
+
+class UnexpectedEofError(ParseError):
+    """
+    The TOML being parsed ended before the end of a statement.
+    """
+
+    def __init__(self, line: int, col: int) -> None:
+        message = "Unexpected end of file"
+
+        super().__init__(line, col, message=message)
+
+
+class InternalParserError(ParseError):
+    """
+    An error that indicates a bug in the parser.
+    """
+
+    def __init__(self, line: int, col: int, message: str | None = None) -> None:
+        msg = "Internal parser error"
+        if message:
+            msg += f" ({message})"
+
+        super().__init__(line, col, message=msg)
+
+
+class NonExistentKey(KeyError, TOMLKitError):
+    """
+    A non-existent key was used.
+    """
+
+    def __init__(self, key):
+        message = f'Key "{key}" does not exist.'
+
+        super().__init__(message)
+
+
+class KeyAlreadyPresent(TOMLKitError):
+    """
+    An already present key was used.
+    """
+
+    def __init__(self, key):
+        key = getattr(key, "key", key)
+        message = f'Key "{key}" already exists.'
+
+        super().__init__(message)
+
+
+class InvalidControlChar(ParseError):
+    def __init__(self, line: int, col: int, char: int, type: str) -> None:
+        display_code = "\\u00"
+
+        if char < 16:
+            display_code += "0"
+
+        display_code += hex(char)[2:]
+
+        message = (
+            "Control characters (codes less than 0x1f and 0x7f)"
+            f" are not allowed in {type}, "
+            f"use {display_code} instead"
+        )
+
+        super().__init__(line, col, message=message)
+
+
+class InvalidStringError(ValueError, TOMLKitError):
+    def __init__(self, value: str, invalid_sequences: Collection[str], delimiter: str):
+        repr_ = repr(value)[1:-1]
+        super().__init__(
+            f"Invalid string: {delimiter}{repr_}{delimiter}. "
+            f"The character sequences {invalid_sequences} are invalid."
+        )