Add files using upload-large-folder tool

.gitattributes

@@ -1316,3 +1316,5 @@ evalkit_tf437/lib/python3.10/site-packages/scipy/io/matlab/_mio5_utils.cpython-3
 evalkit_tf437/lib/python3.10/site-packages/scipy/signal/_upfirdn_apply.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 evalkit_tf437/lib/python3.10/site-packages/scipy/stats/__pycache__/_mstats_basic.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 evalkit_tf437/lib/python3.10/site-packages/scipy/interpolate/_rgi_cython.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+evalkit_tf437/lib/python3.10/site-packages/scipy/linalg/cython_lapack.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+evalkit_tf437/lib/python3.10/site-packages/pandas/core/__pycache__/generic.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

evalkit_tf437/lib/python3.10/site-packages/IPython/lib/tests/test.wav

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

evalkit_tf437/lib/python3.10/site-packages/IPython/terminal/shortcuts/__init__.py

@@ -0,0 +1,630 @@
+"""
+Module to define and register Terminal IPython shortcuts with
+:mod:`prompt_toolkit`
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import signal
+import sys
+import warnings
+from dataclasses import dataclass
+from typing import Callable, Any, Optional, List
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPressEvent
+from prompt_toolkit.key_binding.bindings import named_commands as nc
+from prompt_toolkit.key_binding.bindings.completion import (
+    display_completions_like_readline,
+)
+from prompt_toolkit.key_binding.vi_state import InputMode, ViState
+from prompt_toolkit.filters import Condition
+
+from IPython.core.getipython import get_ipython
+from IPython.terminal.shortcuts import auto_match as match
+from IPython.terminal.shortcuts import auto_suggest
+from IPython.terminal.shortcuts.filters import filter_from_string
+from IPython.utils.decorators import undoc
+
+from prompt_toolkit.enums import DEFAULT_BUFFER
+
+__all__ = ["create_ipython_shortcuts"]
+
+
+@dataclass
+class BaseBinding:
+    command: Callable[[KeyPressEvent], Any]
+    keys: List[str]
+
+
+@dataclass
+class RuntimeBinding(BaseBinding):
+    filter: Condition
+
+
+@dataclass
+class Binding(BaseBinding):
+    # while filter could be created by referencing variables directly (rather
+    # than created from strings), by using strings we ensure that users will
+    # be able to create filters in configuration (e.g. JSON) files too, which
+    # also benefits the documentation by enforcing human-readable filter names.
+    condition: Optional[str] = None
+
+    def __post_init__(self):
+        if self.condition:
+            self.filter = filter_from_string(self.condition)
+        else:
+            self.filter = None
+
+
+def create_identifier(handler: Callable):
+    parts = handler.__module__.split(".")
+    name = handler.__name__
+    package = parts[0]
+    if len(parts) > 1:
+        final_module = parts[-1]
+        return f"{package}:{final_module}.{name}"
+    else:
+        return f"{package}:{name}"
+
+
+AUTO_MATCH_BINDINGS = [
+    *[
+        Binding(
+            cmd, [key], "focused_insert & auto_match & followed_by_closing_paren_or_end"
+        )
+        for key, cmd in match.auto_match_parens.items()
+    ],
+    *[
+        # raw string
+        Binding(cmd, [key], "focused_insert & auto_match & preceded_by_raw_str_prefix")
+        for key, cmd in match.auto_match_parens_raw_string.items()
+    ],
+    Binding(
+        match.double_quote,
+        ['"'],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_paired_double_quotes"
+        " & followed_by_closing_paren_or_end",
+    ),
+    Binding(
+        match.single_quote,
+        ["'"],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_paired_single_quotes"
+        " & followed_by_closing_paren_or_end",
+    ),
+    Binding(
+        match.docstring_double_quotes,
+        ['"'],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_two_double_quotes",
+    ),
+    Binding(
+        match.docstring_single_quotes,
+        ["'"],
+        "focused_insert"
+        " & auto_match"
+        " & not_inside_unclosed_string"
+        " & preceded_by_two_single_quotes",
+    ),
+    Binding(
+        match.skip_over,
+        [")"],
+        "focused_insert & auto_match & followed_by_closing_round_paren",
+    ),
+    Binding(
+        match.skip_over,
+        ["]"],
+        "focused_insert & auto_match & followed_by_closing_bracket",
+    ),
+    Binding(
+        match.skip_over,
+        ["}"],
+        "focused_insert & auto_match & followed_by_closing_brace",
+    ),
+    Binding(
+        match.skip_over, ['"'], "focused_insert & auto_match & followed_by_double_quote"
+    ),
+    Binding(
+        match.skip_over, ["'"], "focused_insert & auto_match & followed_by_single_quote"
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_opening_round_paren"
+        " & auto_match"
+        " & followed_by_closing_round_paren",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_opening_bracket"
+        " & auto_match"
+        " & followed_by_closing_bracket",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_opening_brace"
+        " & auto_match"
+        " & followed_by_closing_brace",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_double_quote"
+        " & auto_match"
+        " & followed_by_double_quote",
+    ),
+    Binding(
+        match.delete_pair,
+        ["backspace"],
+        "focused_insert"
+        " & preceded_by_single_quote"
+        " & auto_match"
+        " & followed_by_single_quote",
+    ),
+]
+
+AUTO_SUGGEST_BINDINGS = [
+    # there are two reasons for re-defining bindings defined upstream:
+    # 1) prompt-toolkit does not execute autosuggestion bindings in vi mode,
+    # 2) prompt-toolkit checks if we are at the end of text, not end of line
+    #    hence it does not work in multi-line mode of navigable provider
+    Binding(
+        auto_suggest.accept_or_jump_to_end,
+        ["end"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_or_jump_to_end,
+        ["c-e"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept,
+        ["c-f"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept,
+        ["right"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_word,
+        ["escape", "f"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_token,
+        ["c-right"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.discard,
+        ["escape"],
+        # note this one is using `emacs_insert_mode`, not `emacs_like_insert_mode`
+        # as in `vi_insert_mode` we do not want `escape` to be shadowed (ever).
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.discard,
+        ["delete"],
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.swap_autosuggestion_up,
+        ["c-up"],
+        "navigable_suggestions"
+        " & ~has_line_above"
+        " & has_suggestion"
+        " & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.swap_autosuggestion_down,
+        ["c-down"],
+        "navigable_suggestions"
+        " & ~has_line_below"
+        " & has_suggestion"
+        " & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.up_and_update_hint,
+        ["c-up"],
+        "has_line_above & navigable_suggestions & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.down_and_update_hint,
+        ["c-down"],
+        "has_line_below & navigable_suggestions & default_buffer_focused",
+    ),
+    Binding(
+        auto_suggest.accept_character,
+        ["escape", "right"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_and_move_cursor_left,
+        ["c-left"],
+        "has_suggestion & default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.accept_and_keep_cursor,
+        ["escape", "down"],
+        "has_suggestion & default_buffer_focused & emacs_insert_mode",
+    ),
+    Binding(
+        auto_suggest.backspace_and_resume_hint,
+        ["backspace"],
+        # no `has_suggestion` here to allow resuming if no suggestion
+        "default_buffer_focused & emacs_like_insert_mode",
+    ),
+    Binding(
+        auto_suggest.resume_hinting,
+        ["right"],
+        "is_cursor_at_the_end_of_line"
+        " & default_buffer_focused"
+        " & emacs_like_insert_mode"
+        " & pass_through",
+    ),
+]
+
+
+SIMPLE_CONTROL_BINDINGS = [
+    Binding(cmd, [key], "vi_insert_mode & default_buffer_focused & ebivim")
+    for key, cmd in {
+        "c-a": nc.beginning_of_line,
+        "c-b": nc.backward_char,
+        "c-k": nc.kill_line,
+        "c-w": nc.backward_kill_word,
+        "c-y": nc.yank,
+        "c-_": nc.undo,
+    }.items()
+]
+
+
+ALT_AND_COMOBO_CONTROL_BINDINGS = [
+    Binding(cmd, list(keys), "vi_insert_mode & default_buffer_focused & ebivim")
+    for keys, cmd in {
+        # Control Combos
+        ("c-x", "c-e"): nc.edit_and_execute,
+        ("c-x", "e"): nc.edit_and_execute,
+        # Alt
+        ("escape", "b"): nc.backward_word,
+        ("escape", "c"): nc.capitalize_word,
+        ("escape", "d"): nc.kill_word,
+        ("escape", "h"): nc.backward_kill_word,
+        ("escape", "l"): nc.downcase_word,
+        ("escape", "u"): nc.uppercase_word,
+        ("escape", "y"): nc.yank_pop,
+        ("escape", "."): nc.yank_last_arg,
+    }.items()
+]
+
+
+def add_binding(bindings: KeyBindings, binding: Binding):
+    bindings.add(
+        *binding.keys,
+        **({"filter": binding.filter} if binding.filter is not None else {}),
+    )(binding.command)
+
+
+def create_ipython_shortcuts(shell, skip=None) -> KeyBindings:
+    """Set up the prompt_toolkit keyboard shortcuts for IPython.
+
+    Parameters
+    ----------
+    shell: InteractiveShell
+        The current IPython shell Instance
+    skip: List[Binding]
+        Bindings to skip.
+
+    Returns
+    -------
+    KeyBindings
+        the keybinding instance for prompt toolkit.
+
+    """
+    kb = KeyBindings()
+    skip = skip or []
+    for binding in KEY_BINDINGS:
+        skip_this_one = False
+        for to_skip in skip:
+            if (
+                to_skip.command == binding.command
+                and to_skip.filter == binding.filter
+                and to_skip.keys == binding.keys
+            ):
+                skip_this_one = True
+                break
+        if skip_this_one:
+            continue
+        add_binding(kb, binding)
+
+    def get_input_mode(self):
+        app = get_app()
+        app.ttimeoutlen = shell.ttimeoutlen
+        app.timeoutlen = shell.timeoutlen
+
+        return self._input_mode
+
+    def set_input_mode(self, mode):
+        shape = {InputMode.NAVIGATION: 2, InputMode.REPLACE: 4}.get(mode, 6)
+        cursor = "\x1b[{} q".format(shape)
+
+        sys.stdout.write(cursor)
+        sys.stdout.flush()
+
+        self._input_mode = mode
+
+    if shell.editing_mode == "vi" and shell.modal_cursor:
+        ViState._input_mode = InputMode.INSERT  # type: ignore
+        ViState.input_mode = property(get_input_mode, set_input_mode)  # type: ignore
+
+    return kb
+
+
+def reformat_and_execute(event):
+    """Reformat code and execute it"""
+    shell = get_ipython()
+    reformat_text_before_cursor(
+        event.current_buffer, event.current_buffer.document, shell
+    )
+    event.current_buffer.validate_and_handle()
+
+
+def reformat_text_before_cursor(buffer, document, shell):
+    text = buffer.delete_before_cursor(len(document.text[: document.cursor_position]))
+    try:
+        formatted_text = shell.reformat_handler(text)
+        buffer.insert_text(formatted_text)
+    except Exception as e:
+        buffer.insert_text(text)
+
+
+def handle_return_or_newline_or_execute(event):
+    shell = get_ipython()
+    if getattr(shell, "handle_return", None):
+        return shell.handle_return(shell)(event)
+    else:
+        return newline_or_execute_outer(shell)(event)
+
+
+def newline_or_execute_outer(shell):
+    def newline_or_execute(event):
+        """When the user presses return, insert a newline or execute the code."""
+        b = event.current_buffer
+        d = b.document
+
+        if b.complete_state:
+            cc = b.complete_state.current_completion
+            if cc:
+                b.apply_completion(cc)
+            else:
+                b.cancel_completion()
+            return
+
+        # If there's only one line, treat it as if the cursor is at the end.
+        # See https://github.com/ipython/ipython/issues/10425
+        if d.line_count == 1:
+            check_text = d.text
+        else:
+            check_text = d.text[: d.cursor_position]
+        status, indent = shell.check_complete(check_text)
+
+        # if all we have after the cursor is whitespace: reformat current text
+        # before cursor
+        after_cursor = d.text[d.cursor_position :]
+        reformatted = False
+        if not after_cursor.strip():
+            reformat_text_before_cursor(b, d, shell)
+            reformatted = True
+        if not (
+            d.on_last_line
+            or d.cursor_position_row >= d.line_count - d.empty_line_count_at_the_end()
+        ):
+            if shell.autoindent:
+                b.insert_text("\n" + indent)
+            else:
+                b.insert_text("\n")
+            return
+
+        if (status != "incomplete") and b.accept_handler:
+            if not reformatted:
+                reformat_text_before_cursor(b, d, shell)
+            b.validate_and_handle()
+        else:
+            if shell.autoindent:
+                b.insert_text("\n" + indent)
+            else:
+                b.insert_text("\n")
+
+    return newline_or_execute
+
+
+def previous_history_or_previous_completion(event):
+    """
+    Control-P in vi edit mode on readline is history next, unlike default prompt toolkit.
+
+    If completer is open this still select previous completion.
+    """
+    event.current_buffer.auto_up()
+
+
+def next_history_or_next_completion(event):
+    """
+    Control-N in vi edit mode on readline is history previous, unlike default prompt toolkit.
+
+    If completer is open this still select next completion.
+    """
+    event.current_buffer.auto_down()
+
+
+def dismiss_completion(event):
+    """Dismiss completion"""
+    b = event.current_buffer
+    if b.complete_state:
+        b.cancel_completion()
+
+
+def reset_buffer(event):
+    """Reset buffer"""
+    b = event.current_buffer
+    if b.complete_state:
+        b.cancel_completion()
+    else:
+        b.reset()
+
+
+def reset_search_buffer(event):
+    """Reset search buffer"""
+    if event.current_buffer.document.text:
+        event.current_buffer.reset()
+    else:
+        event.app.layout.focus(DEFAULT_BUFFER)
+
+
+def suspend_to_bg(event):
+    """Suspend to background"""
+    event.app.suspend_to_background()
+
+
+def quit(event):
+    """
+    Quit application with ``SIGQUIT`` if supported or ``sys.exit`` otherwise.
+
+    On platforms that support SIGQUIT, send SIGQUIT to the current process.
+    On other platforms, just exit the process with a message.
+    """
+    sigquit = getattr(signal, "SIGQUIT", None)
+    if sigquit is not None:
+        os.kill(0, signal.SIGQUIT)
+    else:
+        sys.exit("Quit")
+
+
+def indent_buffer(event):
+    """Indent buffer"""
+    event.current_buffer.insert_text(" " * 4)
+
+
+def newline_autoindent(event):
+    """Insert a newline after the cursor indented appropriately.
+
+    Fancier version of former ``newline_with_copy_margin`` which should
+    compute the correct indentation of the inserted line. That is to say, indent
+    by 4 extra space after a function definition, class definition, context
+    manager... And dedent by 4 space after ``pass``, ``return``, ``raise ...``.
+    """
+    shell = get_ipython()
+    inputsplitter = shell.input_transformer_manager
+    b = event.current_buffer
+    d = b.document
+
+    if b.complete_state:
+        b.cancel_completion()
+    text = d.text[: d.cursor_position] + "\n"
+    _, indent = inputsplitter.check_complete(text)
+    b.insert_text("\n" + (" " * (indent or 0)), move_cursor=False)
+
+
+def open_input_in_editor(event):
+    """Open code from input in external editor"""
+    event.app.current_buffer.open_in_editor()
+
+
+if sys.platform == "win32":
+    from IPython.core.error import TryNext
+    from IPython.lib.clipboard import (
+        ClipboardEmpty,
+        tkinter_clipboard_get,
+        win32_clipboard_get,
+    )
+
+    @undoc
+    def win_paste(event):
+        try:
+            text = win32_clipboard_get()
+        except TryNext:
+            try:
+                text = tkinter_clipboard_get()
+            except (TryNext, ClipboardEmpty):
+                return
+        except ClipboardEmpty:
+            return
+        event.current_buffer.insert_text(text.replace("\t", " " * 4))
+
+else:
+
+    @undoc
+    def win_paste(event):
+        """Stub used on other platforms"""
+        pass
+
+
+KEY_BINDINGS = [
+    Binding(
+        handle_return_or_newline_or_execute,
+        ["enter"],
+        "default_buffer_focused & ~has_selection & insert_mode",
+    ),
+    Binding(
+        reformat_and_execute,
+        ["escape", "enter"],
+        "default_buffer_focused & ~has_selection & insert_mode & ebivim",
+    ),
+    Binding(quit, ["c-\\"]),
+    Binding(
+        previous_history_or_previous_completion,
+        ["c-p"],
+        "vi_insert_mode & default_buffer_focused",
+    ),
+    Binding(
+        next_history_or_next_completion,
+        ["c-n"],
+        "vi_insert_mode & default_buffer_focused",
+    ),
+    Binding(dismiss_completion, ["c-g"], "default_buffer_focused & has_completions"),
+    Binding(reset_buffer, ["c-c"], "default_buffer_focused"),
+    Binding(reset_search_buffer, ["c-c"], "search_buffer_focused"),
+    Binding(suspend_to_bg, ["c-z"], "supports_suspend"),
+    Binding(
+        indent_buffer,
+        ["tab"],  # Ctrl+I == Tab
+        "default_buffer_focused"
+        " & ~has_selection"
+        " & insert_mode"
+        " & cursor_in_leading_ws",
+    ),
+    Binding(newline_autoindent, ["c-o"], "default_buffer_focused & emacs_insert_mode"),
+    Binding(open_input_in_editor, ["f2"], "default_buffer_focused"),
+    *AUTO_MATCH_BINDINGS,
+    *AUTO_SUGGEST_BINDINGS,
+    Binding(
+        display_completions_like_readline,
+        ["c-i"],
+        "readline_like_completions"
+        " & default_buffer_focused"
+        " & ~has_selection"
+        " & insert_mode"
+        " & ~cursor_in_leading_ws",
+    ),
+    Binding(win_paste, ["c-v"], "default_buffer_focused & ~vi_mode & is_windows_os"),
+    *SIMPLE_CONTROL_BINDINGS,
+    *ALT_AND_COMOBO_CONTROL_BINDINGS,
+]

evalkit_tf437/lib/python3.10/site-packages/IPython/terminal/shortcuts/auto_match.py

@@ -0,0 +1,104 @@
+"""
+Utilities function for keybinding with prompt toolkit.
+
+This will be bound to specific key press and filter modes,
+like whether we are in edit mode, and whether the completer is open.
+"""
+import re
+from prompt_toolkit.key_binding import KeyPressEvent
+
+
+def parenthesis(event: KeyPressEvent):
+    """Auto-close parenthesis"""
+    event.current_buffer.insert_text("()")
+    event.current_buffer.cursor_left()
+
+
+def brackets(event: KeyPressEvent):
+    """Auto-close brackets"""
+    event.current_buffer.insert_text("[]")
+    event.current_buffer.cursor_left()
+
+
+def braces(event: KeyPressEvent):
+    """Auto-close braces"""
+    event.current_buffer.insert_text("{}")
+    event.current_buffer.cursor_left()
+
+
+def double_quote(event: KeyPressEvent):
+    """Auto-close double quotes"""
+    event.current_buffer.insert_text('""')
+    event.current_buffer.cursor_left()
+
+
+def single_quote(event: KeyPressEvent):
+    """Auto-close single quotes"""
+    event.current_buffer.insert_text("''")
+    event.current_buffer.cursor_left()
+
+
+def docstring_double_quotes(event: KeyPressEvent):
+    """Auto-close docstring (double quotes)"""
+    event.current_buffer.insert_text('""""')
+    event.current_buffer.cursor_left(3)
+
+
+def docstring_single_quotes(event: KeyPressEvent):
+    """Auto-close docstring (single quotes)"""
+    event.current_buffer.insert_text("''''")
+    event.current_buffer.cursor_left(3)
+
+
+def raw_string_parenthesis(event: KeyPressEvent):
+    """Auto-close parenthesis in raw strings"""
+    matches = re.match(
+        r".*(r|R)[\"'](-*)",
+        event.current_buffer.document.current_line_before_cursor,
+    )
+    dashes = matches.group(2) if matches else ""
+    event.current_buffer.insert_text("()" + dashes)
+    event.current_buffer.cursor_left(len(dashes) + 1)
+
+
+def raw_string_bracket(event: KeyPressEvent):
+    """Auto-close bracker in raw strings"""
+    matches = re.match(
+        r".*(r|R)[\"'](-*)",
+        event.current_buffer.document.current_line_before_cursor,
+    )
+    dashes = matches.group(2) if matches else ""
+    event.current_buffer.insert_text("[]" + dashes)
+    event.current_buffer.cursor_left(len(dashes) + 1)
+
+
+def raw_string_braces(event: KeyPressEvent):
+    """Auto-close braces in raw strings"""
+    matches = re.match(
+        r".*(r|R)[\"'](-*)",
+        event.current_buffer.document.current_line_before_cursor,
+    )
+    dashes = matches.group(2) if matches else ""
+    event.current_buffer.insert_text("{}" + dashes)
+    event.current_buffer.cursor_left(len(dashes) + 1)
+
+
+def skip_over(event: KeyPressEvent):
+    """Skip over automatically added parenthesis/quote.
+
+    (rather than adding another parenthesis/quote)"""
+    event.current_buffer.cursor_right()
+
+
+def delete_pair(event: KeyPressEvent):
+    """Delete auto-closed parenthesis"""
+    event.current_buffer.delete()
+    event.current_buffer.delete_before_cursor()
+
+
+auto_match_parens = {"(": parenthesis, "[": brackets, "{": braces}
+auto_match_parens_raw_string = {
+    "(": raw_string_parenthesis,
+    "[": raw_string_bracket,
+    "{": raw_string_braces,
+}

evalkit_tf437/lib/python3.10/site-packages/IPython/terminal/shortcuts/filters.py

@@ -0,0 +1,322 @@
+"""
+Filters restricting scope of IPython Terminal shortcuts.
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import ast
+import re
+import signal
+import sys
+from typing import Callable, Dict, Union
+
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER
+from prompt_toolkit.key_binding import KeyPressEvent
+from prompt_toolkit.filters import Condition, Filter, emacs_insert_mode, has_completions
+from prompt_toolkit.filters import has_focus as has_focus_impl
+from prompt_toolkit.filters import (
+    Always,
+    Never,
+    has_selection,
+    has_suggestion,
+    vi_insert_mode,
+    vi_mode,
+)
+from prompt_toolkit.layout.layout import FocusableElement
+
+from IPython.core.getipython import get_ipython
+from IPython.core.guarded_eval import _find_dunder, BINARY_OP_DUNDERS, UNARY_OP_DUNDERS
+from IPython.terminal.shortcuts import auto_suggest
+from IPython.utils.decorators import undoc
+
+
+@undoc
+@Condition
+def cursor_in_leading_ws():
+    before = get_app().current_buffer.document.current_line_before_cursor
+    return (not before) or before.isspace()
+
+
+def has_focus(value: FocusableElement):
+    """Wrapper around has_focus adding a nice `__name__` to tester function"""
+    tester = has_focus_impl(value).func
+    tester.__name__ = f"is_focused({value})"
+    return Condition(tester)
+
+
+@undoc
+@Condition
+def has_line_below() -> bool:
+    document = get_app().current_buffer.document
+    return document.cursor_position_row < len(document.lines) - 1
+
+
+@undoc
+@Condition
+def is_cursor_at_the_end_of_line() -> bool:
+    document = get_app().current_buffer.document
+    return document.is_cursor_at_the_end_of_line
+
+
+@undoc
+@Condition
+def has_line_above() -> bool:
+    document = get_app().current_buffer.document
+    return document.cursor_position_row != 0
+
+
+@Condition
+def ebivim():
+    shell = get_ipython()
+    return shell.emacs_bindings_in_vi_insert_mode
+
+
+@Condition
+def supports_suspend():
+    return hasattr(signal, "SIGTSTP")
+
+
+@Condition
+def auto_match():
+    shell = get_ipython()
+    return shell.auto_match
+
+
+def all_quotes_paired(quote, buf):
+    paired = True
+    i = 0
+    while i < len(buf):
+        c = buf[i]
+        if c == quote:
+            paired = not paired
+        elif c == "\\":
+            i += 1
+        i += 1
+    return paired
+
+
+_preceding_text_cache: Dict[Union[str, Callable], Condition] = {}
+_following_text_cache: Dict[Union[str, Callable], Condition] = {}
+
+
+def preceding_text(pattern: Union[str, Callable]):
+    if pattern in _preceding_text_cache:
+        return _preceding_text_cache[pattern]
+
+    if callable(pattern):
+
+        def _preceding_text():
+            app = get_app()
+            before_cursor = app.current_buffer.document.current_line_before_cursor
+            # mypy can't infer if(callable): https://github.com/python/mypy/issues/3603
+            return bool(pattern(before_cursor))  # type: ignore[operator]
+
+    else:
+        m = re.compile(pattern)
+
+        def _preceding_text():
+            app = get_app()
+            before_cursor = app.current_buffer.document.current_line_before_cursor
+            return bool(m.match(before_cursor))
+
+        _preceding_text.__name__ = f"preceding_text({pattern!r})"
+
+    condition = Condition(_preceding_text)
+    _preceding_text_cache[pattern] = condition
+    return condition
+
+
+def following_text(pattern):
+    try:
+        return _following_text_cache[pattern]
+    except KeyError:
+        pass
+    m = re.compile(pattern)
+
+    def _following_text():
+        app = get_app()
+        return bool(m.match(app.current_buffer.document.current_line_after_cursor))
+
+    _following_text.__name__ = f"following_text({pattern!r})"
+
+    condition = Condition(_following_text)
+    _following_text_cache[pattern] = condition
+    return condition
+
+
+@Condition
+def not_inside_unclosed_string():
+    app = get_app()
+    s = app.current_buffer.document.text_before_cursor
+    # remove escaped quotes
+    s = s.replace('\\"', "").replace("\\'", "")
+    # remove triple-quoted string literals
+    s = re.sub(r"(?:\"\"\"[\s\S]*\"\"\"|'''[\s\S]*''')", "", s)
+    # remove single-quoted string literals
+    s = re.sub(r"""(?:"[^"]*["\n]|'[^']*['\n])""", "", s)
+    return not ('"' in s or "'" in s)
+
+
+@Condition
+def navigable_suggestions():
+    shell = get_ipython()
+    return isinstance(shell.auto_suggest, auto_suggest.NavigableAutoSuggestFromHistory)
+
+
+@Condition
+def readline_like_completions():
+    shell = get_ipython()
+    return shell.display_completions == "readlinelike"
+
+
+@Condition
+def is_windows_os():
+    return sys.platform == "win32"
+
+
+class PassThrough(Filter):
+    """A filter allowing to implement pass-through behaviour of keybindings.
+
+    Prompt toolkit key processor dispatches only one event per binding match,
+    which means that adding a new shortcut will suppress the old shortcut
+    if the keybindings are the same (unless one is filtered out).
+
+    To stop a shortcut binding from suppressing other shortcuts:
+    - add the `pass_through` filter to list of filter, and
+    - call `pass_through.reply(event)` in the shortcut handler.
+    """
+
+    def __init__(self):
+        self._is_replying = False
+
+    def reply(self, event: KeyPressEvent):
+        self._is_replying = True
+        try:
+            event.key_processor.reset()
+            event.key_processor.feed_multiple(event.key_sequence)
+            event.key_processor.process_keys()
+        finally:
+            self._is_replying = False
+
+    def __call__(self):
+        return not self._is_replying
+
+
+pass_through = PassThrough()
+
+# these one is callable and re-used multiple times hence needs to be
+# only defined once beforehand so that transforming back to human-readable
+# names works well in the documentation.
+default_buffer_focused = has_focus(DEFAULT_BUFFER)
+
+KEYBINDING_FILTERS = {
+    "always": Always(),
+    # never is used for exposing commands which have no default keybindings
+    "never": Never(),
+    "has_line_below": has_line_below,
+    "has_line_above": has_line_above,
+    "is_cursor_at_the_end_of_line": is_cursor_at_the_end_of_line,
+    "has_selection": has_selection,
+    "has_suggestion": has_suggestion,
+    "vi_mode": vi_mode,
+    "vi_insert_mode": vi_insert_mode,
+    "emacs_insert_mode": emacs_insert_mode,
+    # https://github.com/ipython/ipython/pull/12603 argued for inclusion of
+    # emacs key bindings with a configurable `emacs_bindings_in_vi_insert_mode`
+    # toggle; when the toggle is on user can access keybindigns like `ctrl + e`
+    # in vi insert mode. Because some of the emacs bindings involve `escape`
+    # followed by another key, e.g. `escape` followed by `f`, prompt-toolkit
+    # needs to wait to see if there will be another character typed in before
+    # executing pure `escape` keybinding; in vi insert mode `escape` switches to
+    # command mode which is common and performance critical action for vi users.
+    # To avoid the delay users employ a workaround:
+    # https://github.com/ipython/ipython/issues/13443#issuecomment-1032753703
+    # which involves switching `emacs_bindings_in_vi_insert_mode` off.
+    #
+    # For the workaround to work:
+    # 1) end users need to toggle `emacs_bindings_in_vi_insert_mode` off
+    # 2) all keybindings which would involve `escape` need to respect that
+    #    toggle by including either:
+    #      - `vi_insert_mode & ebivim` for actions which have emacs keybindings
+    #        predefined upstream in prompt-toolkit, or
+    #      - `emacs_like_insert_mode` for actions which do not have existing
+    #        emacs keybindings predefined upstream (or need overriding of the
+    #        upstream bindings to modify behaviour), defined below.
+    "emacs_like_insert_mode": (vi_insert_mode & ebivim) | emacs_insert_mode,
+    "has_completions": has_completions,
+    "insert_mode": vi_insert_mode | emacs_insert_mode,
+    "default_buffer_focused": default_buffer_focused,
+    "search_buffer_focused": has_focus(SEARCH_BUFFER),
+    # `ebivim` stands for emacs bindings in vi insert mode
+    "ebivim": ebivim,
+    "supports_suspend": supports_suspend,
+    "is_windows_os": is_windows_os,
+    "auto_match": auto_match,
+    "focused_insert": (vi_insert_mode | emacs_insert_mode) & default_buffer_focused,
+    "not_inside_unclosed_string": not_inside_unclosed_string,
+    "readline_like_completions": readline_like_completions,
+    "preceded_by_paired_double_quotes": preceding_text(
+        lambda line: all_quotes_paired('"', line)
+    ),
+    "preceded_by_paired_single_quotes": preceding_text(
+        lambda line: all_quotes_paired("'", line)
+    ),
+    "preceded_by_raw_str_prefix": preceding_text(r".*(r|R)[\"'](-*)$"),
+    "preceded_by_two_double_quotes": preceding_text(r'^.*""$'),
+    "preceded_by_two_single_quotes": preceding_text(r"^.*''$"),
+    "followed_by_closing_paren_or_end": following_text(r"[,)}\]]|$"),
+    "preceded_by_opening_round_paren": preceding_text(r".*\($"),
+    "preceded_by_opening_bracket": preceding_text(r".*\[$"),
+    "preceded_by_opening_brace": preceding_text(r".*\{$"),
+    "preceded_by_double_quote": preceding_text('.*"$'),
+    "preceded_by_single_quote": preceding_text(r".*'$"),
+    "followed_by_closing_round_paren": following_text(r"^\)"),
+    "followed_by_closing_bracket": following_text(r"^\]"),
+    "followed_by_closing_brace": following_text(r"^\}"),
+    "followed_by_double_quote": following_text('^"'),
+    "followed_by_single_quote": following_text("^'"),
+    "navigable_suggestions": navigable_suggestions,
+    "cursor_in_leading_ws": cursor_in_leading_ws,
+    "pass_through": pass_through,
+}
+
+
+def eval_node(node: Union[ast.AST, None]):
+    if node is None:
+        return None
+    if isinstance(node, ast.Expression):
+        return eval_node(node.body)
+    if isinstance(node, ast.BinOp):
+        left = eval_node(node.left)
+        right = eval_node(node.right)
+        dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
+        if dunders:
+            return getattr(left, dunders[0])(right)
+        raise ValueError(f"Unknown binary operation: {node.op}")
+    if isinstance(node, ast.UnaryOp):
+        value = eval_node(node.operand)
+        dunders = _find_dunder(node.op, UNARY_OP_DUNDERS)
+        if dunders:
+            return getattr(value, dunders[0])()
+        raise ValueError(f"Unknown unary operation: {node.op}")
+    if isinstance(node, ast.Name):
+        if node.id in KEYBINDING_FILTERS:
+            return KEYBINDING_FILTERS[node.id]
+        else:
+            sep = "\n  - "
+            known_filters = sep.join(sorted(KEYBINDING_FILTERS))
+            raise NameError(
+                f"{node.id} is not a known shortcut filter."
+                f" Known filters are: {sep}{known_filters}."
+            )
+    raise ValueError("Unhandled node", ast.dump(node))
+
+
+def filter_from_string(code: str):
+    expression = ast.parse(code, mode="eval")
+    return eval_node(expression)
+
+
+__all__ = ["KEYBINDING_FILTERS", "filter_from_string"]

evalkit_tf437/lib/python3.10/site-packages/IPython/terminal/tests/test_help.py

@@ -0,0 +1,30 @@
+"""Test help output of various IPython entry points"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import pytest
+import IPython.testing.tools as tt
+
+
+def test_ipython_help():
+    tt.help_all_output_test()
+
+def test_profile_help():
+    tt.help_all_output_test("profile")
+
+def test_profile_list_help():
+    tt.help_all_output_test("profile list")
+
+def test_profile_create_help():
+    tt.help_all_output_test("profile create")
+
+def test_locate_help():
+    tt.help_all_output_test("locate")
+
+def test_locate_profile_help():
+    tt.help_all_output_test("locate profile")
+
+def test_trust_help():
+    pytest.importorskip("nbformat")
+    tt.help_all_output_test("trust")

evalkit_tf437/lib/python3.10/site-packages/IPython/terminal/tests/test_interactivshell.py

@@ -0,0 +1,255 @@
+# -*- coding: utf-8 -*-
+"""Tests for the TerminalInteractiveShell and related pieces."""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import sys
+import unittest
+import os
+
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+
+
+from IPython.testing import tools as tt
+
+from IPython.terminal.ptutils import _elide, _adjust_completion_text_based_on_context
+from IPython.terminal.shortcuts.auto_suggest import NavigableAutoSuggestFromHistory
+
+
+class TestAutoSuggest(unittest.TestCase):
+    def test_changing_provider(self):
+        ip = get_ipython()
+        ip.autosuggestions_provider = None
+        self.assertEqual(ip.auto_suggest, None)
+        ip.autosuggestions_provider = "AutoSuggestFromHistory"
+        self.assertIsInstance(ip.auto_suggest, AutoSuggestFromHistory)
+        ip.autosuggestions_provider = "NavigableAutoSuggestFromHistory"
+        self.assertIsInstance(ip.auto_suggest, NavigableAutoSuggestFromHistory)
+
+
+class TestElide(unittest.TestCase):
+    def test_elide(self):
+        _elide("concatenate((a1, a2, ...), axis", "")  # do not raise
+        _elide("concatenate((a1, a2, ..), . axis", "")  # do not raise
+        self.assertEqual(
+            _elide("aaaa.bbbb.ccccc.dddddd.eeeee.fffff.gggggg.hhhhhh", ""),
+            "aaaa.b…g.hhhhhh",
+        )
+
+        test_string = os.sep.join(["", 10 * "a", 10 * "b", 10 * "c", ""])
+        expect_string = (
+            os.sep + "a" + "\N{HORIZONTAL ELLIPSIS}" + "b" + os.sep + 10 * "c"
+        )
+        self.assertEqual(_elide(test_string, ""), expect_string)
+
+    def test_elide_typed_normal(self):
+        self.assertEqual(
+            _elide(
+                "the quick brown fox jumped over the lazy dog",
+                "the quick brown fox",
+                min_elide=10,
+            ),
+            "the…fox jumped over the lazy dog",
+        )
+
+    def test_elide_typed_short_match(self):
+        """
+        if the match is too short we don't elide.
+        avoid the "the...the"
+        """
+        self.assertEqual(
+            _elide("the quick brown fox jumped over the lazy dog", "the", min_elide=10),
+            "the quick brown fox jumped over the lazy dog",
+        )
+
+    def test_elide_typed_no_match(self):
+        """
+        if the match is too short we don't elide.
+        avoid the "the...the"
+        """
+        # here we typed red instead of brown
+        self.assertEqual(
+            _elide(
+                "the quick brown fox jumped over the lazy dog",
+                "the quick red fox",
+                min_elide=10,
+            ),
+            "the quick brown fox jumped over the lazy dog",
+        )
+
+
+class TestContextAwareCompletion(unittest.TestCase):
+    def test_adjust_completion_text_based_on_context(self):
+        # Adjusted case
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a=)", 7), "arg1"
+        )
+
+        # Untouched cases
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a)", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("arg1=", "func1(a", 7), "arg1="
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("%magic", "func1(a=)", 7), "%magic"
+        )
+        self.assertEqual(
+            _adjust_completion_text_based_on_context("func2", "func1(a=)", 7), "func2"
+        )
+
+
+# Decorator for interaction loop tests -----------------------------------------
+
+
+class mock_input_helper(object):
+    """Machinery for tests of the main interact loop.
+
+    Used by the mock_input decorator.
+    """
+    def __init__(self, testgen):
+        self.testgen = testgen
+        self.exception = None
+        self.ip = get_ipython()
+
+    def __enter__(self):
+        self.orig_prompt_for_code = self.ip.prompt_for_code
+        self.ip.prompt_for_code = self.fake_input
+        return self
+
+    def __exit__(self, etype, value, tb):
+        self.ip.prompt_for_code = self.orig_prompt_for_code
+
+    def fake_input(self):
+        try:
+            return next(self.testgen)
+        except StopIteration:
+            self.ip.keep_running = False
+            return u''
+        except:
+            self.exception = sys.exc_info()
+            self.ip.keep_running = False
+            return u''
+
+def mock_input(testfunc):
+    """Decorator for tests of the main interact loop.
+
+    Write the test as a generator, yield-ing the input strings, which IPython
+    will see as if they were typed in at the prompt.
+    """
+    def test_method(self):
+        testgen = testfunc(self)
+        with mock_input_helper(testgen) as mih:
+            mih.ip.interact()
+
+        if mih.exception is not None:
+            # Re-raise captured exception
+            etype, value, tb = mih.exception
+            import traceback
+            traceback.print_tb(tb, file=sys.stdout)
+            del tb  # Avoid reference loop
+            raise value
+
+    return test_method
+
+# Test classes -----------------------------------------------------------------
+
+class InteractiveShellTestCase(unittest.TestCase):
+    def rl_hist_entries(self, rl, n):
+        """Get last n readline history entries as a list"""
+        return [rl.get_history_item(rl.get_current_history_length() - x)
+                for x in range(n - 1, -1, -1)]
+    
+    @mock_input
+    def test_inputtransformer_syntaxerror(self):
+        ip = get_ipython()
+        ip.input_transformers_post.append(syntax_error_transformer)
+
+        try:
+            #raise Exception
+            with tt.AssertPrints('4', suppress=False):
+                yield u'print(2*2)'
+
+            with tt.AssertPrints('SyntaxError: input contains', suppress=False):
+                yield u'print(2345) # syntaxerror'
+
+            with tt.AssertPrints('16', suppress=False):
+                yield u'print(4*4)'
+
+        finally:
+            ip.input_transformers_post.remove(syntax_error_transformer)
+
+    def test_repl_not_plain_text(self):
+        ip = get_ipython()
+        formatter = ip.display_formatter
+        assert formatter.active_types == ['text/plain']
+
+        # terminal may have arbitrary mimetype handler to open external viewer
+        # or inline images.
+        assert formatter.ipython_display_formatter.enabled
+
+        class Test(object):
+            def __repr__(self):
+                return "<Test %i>" % id(self)
+
+            def _repr_html_(self):
+                return '<html>'
+
+        # verify that HTML repr isn't computed
+        obj = Test()
+        data, _ = formatter.format(obj)
+        self.assertEqual(data, {'text/plain': repr(obj)})
+
+        class Test2(Test):
+            def _ipython_display_(self):
+                from IPython.display import display, HTML
+
+                display(HTML("<custom>"))
+
+        # verify that mimehandlers are called
+        called = False
+
+        def handler(data, metadata):
+            print("Handler called")
+            nonlocal called
+            called = True
+
+        ip.display_formatter.active_types.append("text/html")
+        ip.display_formatter.formatters["text/html"].enabled = True
+        ip.mime_renderers["text/html"] = handler
+        try:
+            obj = Test()
+            display(obj)
+        finally:
+            ip.display_formatter.formatters["text/html"].enabled = False
+            del ip.mime_renderers["text/html"]
+
+        assert called == True
+
+
+def syntax_error_transformer(lines):
+    """Transformer that throws SyntaxError if 'syntaxerror' is in the code."""
+    for line in lines:
+        pos = line.find('syntaxerror')
+        if pos >= 0:
+            e = SyntaxError('input contains "syntaxerror"')
+            e.text = line
+            e.offset = pos + 1
+            raise e
+    return lines
+
+
+class TerminalMagicsTestCase(unittest.TestCase):
+    def test_paste_magics_blankline(self):
+        """Test that code with a blank line doesn't get split (gh-3246)."""
+        ip = get_ipython()
+        s = ('def pasted_func(a):\n'
+             '    b = a+1\n'
+             '\n'
+             '    return b')
+        
+        tm = ip.magics_manager.registry['TerminalMagics']
+        tm.store_or_execute(s, name=None)
+        
+        self.assertEqual(ip.user_ns['pasted_func'](54), 55)

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

@@ -0,0 +1,4 @@
+from .core import contents, where
+
+__all__ = ["contents", "where"]
+__version__ = "2024.08.30"

evalkit_tf437/lib/python3.10/site-packages/certifi/__main__.py

@@ -0,0 +1,12 @@
+import argparse
+
+from certifi import contents, where
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-c", "--contents", action="store_true")
+args = parser.parse_args()
+
+if args.contents:
+    print(contents())
+else:
+    print(where())

evalkit_tf437/lib/python3.10/site-packages/certifi/core.py

@@ -0,0 +1,114 @@
+"""
+certifi.py
+~~~~~~~~~~
+
+This module returns the installation location of cacert.pem or its contents.
+"""
+import sys
+import atexit
+
+def exit_cacert_ctx() -> None:
+    _CACERT_CTX.__exit__(None, None, None)  # type: ignore[union-attr]
+
+
+if sys.version_info >= (3, 11):
+
+    from importlib.resources import as_file, files
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the file
+        # in cases where we're inside of a zipimport situation until someone
+        # actually calls where(), but we don't want to re-extract the file
+        # on every call of where(), so we'll do it once then store it in a
+        # global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you to
+            # manage the cleanup of this file, so it doesn't actually return a
+            # path, it returns a context manager that will give you the path
+            # when you enter it and will do any cleanup when you leave it. In
+            # the common case of not needing a temporary file, it will just
+            # return the file system location and the __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = as_file(files("certifi").joinpath("cacert.pem"))
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return files("certifi").joinpath("cacert.pem").read_text(encoding="ascii")
+
+elif sys.version_info >= (3, 7):
+
+    from importlib.resources import path as get_path, read_text
+
+    _CACERT_CTX = None
+    _CACERT_PATH = None
+
+    def where() -> str:
+        # This is slightly terrible, but we want to delay extracting the
+        # file in cases where we're inside of a zipimport situation until
+        # someone actually calls where(), but we don't want to re-extract
+        # the file on every call of where(), so we'll do it once then store
+        # it in a global variable.
+        global _CACERT_CTX
+        global _CACERT_PATH
+        if _CACERT_PATH is None:
+            # This is slightly janky, the importlib.resources API wants you
+            # to manage the cleanup of this file, so it doesn't actually
+            # return a path, it returns a context manager that will give
+            # you the path when you enter it and will do any cleanup when
+            # you leave it. In the common case of not needing a temporary
+            # file, it will just return the file system location and the
+            # __exit__() is a no-op.
+            #
+            # We also have to hold onto the actual context manager, because
+            # it will do the cleanup whenever it gets garbage collected, so
+            # we will also store that at the global level as well.
+            _CACERT_CTX = get_path("certifi", "cacert.pem")
+            _CACERT_PATH = str(_CACERT_CTX.__enter__())
+            atexit.register(exit_cacert_ctx)
+
+        return _CACERT_PATH
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")
+
+else:
+    import os
+    import types
+    from typing import Union
+
+    Package = Union[types.ModuleType, str]
+    Resource = Union[str, "os.PathLike"]
+
+    # This fallback will work for Python versions prior to 3.7 that lack the
+    # importlib.resources module but relies on the existing `where` function
+    # so won't address issues with environments like PyOxidizer that don't set
+    # __file__ on modules.
+    def read_text(
+        package: Package,
+        resource: Resource,
+        encoding: str = 'utf-8',
+        errors: str = 'strict'
+    ) -> str:
+        with open(where(), encoding=encoding) as data:
+            return data.read()
+
+    # If we don't have importlib.resources, then we will just do the old logic
+    # of assuming we're on the filesystem and munge the path directly.
+    def where() -> str:
+        f = os.path.dirname(__file__)
+
+        return os.path.join(f, "cacert.pem")
+
+    def contents() -> str:
+        return read_text("certifi", "cacert.pem", encoding="ascii")

evalkit_tf437/lib/python3.10/site-packages/moviepy-1.0.3.dist-info/INSTALLER

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

evalkit_tf437/lib/python3.10/site-packages/moviepy-1.0.3.dist-info/LICENCE.txt

@@ -0,0 +1,25 @@
+The MIT License (MIT)
+[OSI Approved License]
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Zulko
+
+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/moviepy-1.0.3.dist-info/RECORD

@@ -0,0 +1,181 @@
+moviepy-1.0.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+moviepy-1.0.3.dist-info/LICENCE.txt,sha256=AdwAlHG0Q8vAzROYN8BFt1Em-GmUii725Bno1yGvUho,1119
+moviepy-1.0.3.dist-info/METADATA,sha256=UsjskN_5CrDz4MFazB_8Wqvbe_GO_l5W3UFkrapKbgg,12503
+moviepy-1.0.3.dist-info/RECORD,,
+moviepy-1.0.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moviepy-1.0.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+moviepy-1.0.3.dist-info/top_level.txt,sha256=2AuAzBHXS1RtsoIY43fmVUdf9ZmzoOHlkkBOmciPVBU,8
+moviepy/Clip.py,sha256=T5J4kgcTrOlRtpROEUWtNkZmeHanTOHWcAXtaN11J88,16025
+moviepy/__init__.py,sha256=Jzb_RfgvXCrm_SQ4AfeGVi1N36YybxnM5mpyxrnihgI,33
+moviepy/__pycache__/Clip.cpython-310.pyc,,
+moviepy/__pycache__/__init__.cpython-310.pyc,,
+moviepy/__pycache__/compat.cpython-310.pyc,,
+moviepy/__pycache__/config.cpython-310.pyc,,
+moviepy/__pycache__/config_defaults.cpython-310.pyc,,
+moviepy/__pycache__/decorators.cpython-310.pyc,,
+moviepy/__pycache__/editor.cpython-310.pyc,,
+moviepy/__pycache__/tools.cpython-310.pyc,,
+moviepy/__pycache__/utils.cpython-310.pyc,,
+moviepy/__pycache__/version.cpython-310.pyc,,
+moviepy/audio/AudioClip.py,sha256=blce9zksB5CgOwkBzzbiqsuAuNr2YSmUczJNbMHuIYk,10899
+moviepy/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moviepy/audio/__pycache__/AudioClip.cpython-310.pyc,,
+moviepy/audio/__pycache__/__init__.cpython-310.pyc,,
+moviepy/audio/fx/__init__.py,sha256=QiLpB-Tq7n8ywyj769E67G47_TIF8uW7SICHSb3BZc4,121
+moviepy/audio/fx/__pycache__/__init__.cpython-310.pyc,,
+moviepy/audio/fx/__pycache__/audio_fadein.cpython-310.pyc,,
+moviepy/audio/fx/__pycache__/audio_fadeout.cpython-310.pyc,,
+moviepy/audio/fx/__pycache__/audio_left_right.cpython-310.pyc,,
+moviepy/audio/fx/__pycache__/audio_loop.cpython-310.pyc,,
+moviepy/audio/fx/__pycache__/audio_normalize.cpython-310.pyc,,
+moviepy/audio/fx/__pycache__/volumex.cpython-310.pyc,,
+moviepy/audio/fx/all/__init__.py,sha256=65Vuie1xarBAaMlJ-Ej4MqvVtSF-KOqE2hh0bmqKUus,318
+moviepy/audio/fx/all/__pycache__/__init__.cpython-310.pyc,,
+moviepy/audio/fx/audio_fadein.py,sha256=c5LXJow5UmuAD32L9nwMXfMmgdaN2zf2Tq4i0pCLkYc,632
+moviepy/audio/fx/audio_fadeout.py,sha256=zR61frbcZ1lDmMa04JNpgru7HA1oS7F3XkL5LQFMWjk,703
+moviepy/audio/fx/audio_left_right.py,sha256=nIY9aEyCJVZLBJEyOiUDv490RY-1qdsjzWMkC4oN4j0,501
+moviepy/audio/fx/audio_loop.py,sha256=_CYIkNHVGEToWDaEt8fv8yNLkRAEkB6g9BDop8W3mbo,761
+moviepy/audio/fx/audio_normalize.py,sha256=YybQD5AFBjm_dEe3aZ5Se7LCc010lbojPCaZpiWv_KE,530
+moviepy/audio/fx/volumex.py,sha256=-iL2D2rmwJQ39BwqJ1iXitPoEBkNME62USW-3d4Za78,657
+moviepy/audio/io/AudioFileClip.py,sha256=o7_uluimUOXWwXCVpij68yspmEkUC8R64AGti66DrM4,2801
+moviepy/audio/io/__init__.py,sha256=ozgif9QB2xrWan5VQoAMRbxql6T2RaNA9bNDq6kUtsM,62
+moviepy/audio/io/__pycache__/AudioFileClip.cpython-310.pyc,,
+moviepy/audio/io/__pycache__/__init__.cpython-310.pyc,,
+moviepy/audio/io/__pycache__/ffmpeg_audiowriter.cpython-310.pyc,,
+moviepy/audio/io/__pycache__/preview.cpython-310.pyc,,
+moviepy/audio/io/__pycache__/readers.cpython-310.pyc,,
+moviepy/audio/io/ffmpeg_audiowriter.py,sha256=ssVCDxoR9ZE5pV7ZrkYDHVm7_A0I4k1s0k_wGoL17xc,6265
+moviepy/audio/io/preview.py,sha256=MFotqzyd40vtJEJB4x0F8wR7RyXUWIhMGw7Ag5fahC0,2187
+moviepy/audio/io/readers.py,sha256=YPdZOlhpXUfy16SJUKEM1JVkSgSG8fxbLOnGvEH02k8,8557
+moviepy/audio/tools/__init__.py,sha256=ngcg4cOdZb-tTf72nTMGavfAUK0IhHOB1mMW4dQCkn0,48
+moviepy/audio/tools/__pycache__/__init__.cpython-310.pyc,,
+moviepy/audio/tools/__pycache__/cuts.cpython-310.pyc,,
+moviepy/audio/tools/cuts.py,sha256=_YGlGWBXJIe7oBfhCUHk8mjvEajha7Mev8feVoVKjMs,686
+moviepy/compat.py,sha256=Nba-F62uAuVOv1EJTuwwGqWhr1VyMPW0b2uxS_qVV0Y,303
+moviepy/config.py,sha256=HwS1uQxirlCuDOxuaXLYAYImI0fpubiiPlikqrhGVU4,3474
+moviepy/config_defaults.py,sha256=zHwjL-u7p2TDABWkEE7NUsP-1WM9Hr2uZ-Xs85j7VdU,1571
+moviepy/decorators.py,sha256=mBQ6kz8FRNpIh6xjOQtPW3UVoINZ6M-hlb_VeIHhBq8,3868
+moviepy/editor.py,sha256=lnpUJqk42qfYhL1ReAOMsnGxVapgZi2psKTh8Y8uya8,4108
+moviepy/tools.py,sha256=mUC5IBvpBNacXZZ6gC2G76CnhzKeyxN6fV9VSQJogu8,5260
+moviepy/utils.py,sha256=cLVYHsLxHi1ffLeTl7lYhz-GME5m9Juu5AvmgG1HTSM,609
+moviepy/version.py,sha256=2plzdEEb24FLjE2I2XyBBcJEPYWHccNL4SgtLC_6erg,22
+moviepy/video/VideoClip.py,sha256=nUr7jDP-c2CgjRFw_ImDFqW8ObJEHhdsre1HlQhQ6vE,41252
+moviepy/video/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moviepy/video/__pycache__/VideoClip.cpython-310.pyc,,
+moviepy/video/__pycache__/__init__.cpython-310.pyc,,
+moviepy/video/compositing/CompositeVideoClip.py,sha256=3U5OoeAaWokpsbLLmY-VwgyUthsbYF7h-pXZV2ufTEg,5657
+moviepy/video/compositing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moviepy/video/compositing/__pycache__/CompositeVideoClip.cpython-310.pyc,,
+moviepy/video/compositing/__pycache__/__init__.cpython-310.pyc,,
+moviepy/video/compositing/__pycache__/concatenate.cpython-310.pyc,,
+moviepy/video/compositing/__pycache__/on_color.cpython-310.pyc,,
+moviepy/video/compositing/__pycache__/positioning.cpython-310.pyc,,
+moviepy/video/compositing/__pycache__/transitions.cpython-310.pyc,,
+moviepy/video/compositing/concatenate.py,sha256=YVQnt4GlZYIYYtIGFfsF64pDsUu1JHCMpAEueo7QZv4,4604
+moviepy/video/compositing/on_color.py,sha256=DjXkm8y8-vmUo2QfkNFjVr5SP8T7IhYoIDJv1KJzOtM,1053
+moviepy/video/compositing/positioning.py,sha256=6fk_iD_juI-cuReU92JgBE8PImPogfeJ4vUhhW9vx84,87
+moviepy/video/compositing/transitions.py,sha256=bZWjbjVkYhBCVRIeGT8ydha9XES-YUguVZLCik1Uzv4,3926
+moviepy/video/fx/__init__.py,sha256=QiLpB-Tq7n8ywyj769E67G47_TIF8uW7SICHSb3BZc4,121
+moviepy/video/fx/__pycache__/__init__.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/accel_decel.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/blackwhite.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/blink.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/colorx.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/crop.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/even_size.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/fadein.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/fadeout.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/freeze.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/freeze_region.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/gamma_corr.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/headblur.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/invert_colors.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/loop.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/lum_contrast.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/make_loopable.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/margin.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/mask_and.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/mask_color.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/mask_or.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/mirror_x.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/mirror_y.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/painting.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/resize.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/rotate.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/scroll.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/speedx.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/supersample.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/time_mirror.cpython-310.pyc,,
+moviepy/video/fx/__pycache__/time_symmetrize.cpython-310.pyc,,
+moviepy/video/fx/accel_decel.py,sha256=n-jIw5KDWcMcOyC7xJf7VD5ZHKc-lXOjpeLqFUEkRf0,1225
+moviepy/video/fx/all/__init__.py,sha256=qetnjhZ2DBMOcy5HcnDVWdbQ8imohA1a_vulUSOD4F8,348
+moviepy/video/fx/all/__pycache__/__init__.cpython-310.pyc,,
+moviepy/video/fx/blackwhite.py,sha256=eEFRFRKPSTYtxE9BlwZ-VUlXuWkaJZHz-jyHopUgo00,678
+moviepy/video/fx/blink.py,sha256=2KST8bscD_MCoYf8z4Vv1_czrnQmJDuwYk29OPMywtM,424
+moviepy/video/fx/colorx.py,sha256=01d1qya5Rcy8d4yWWFsDWQpMMVq6QdPxWuWYCFQtYjM,356
+moviepy/video/fx/crop.py,sha256=T4UIUbFKzgLX1xdJhAX4dswcrasZBpaiVGHaKeomCa0,1618
+moviepy/video/fx/even_size.py,sha256=deRjldfdEnoCjwCBkq8GBUPkwWmSlSxl7zqoYQMC_1E,486
+moviepy/video/fx/fadein.py,sha256=7sgU5i4z4ixoNsH1bY5CPF6nfTFA1DHQdW6AH-5Qegk,778
+moviepy/video/fx/fadeout.py,sha256=bEcSvtQJW0dR1e51FVfBtphNQH9UEgJbBa2-3apMRSA,859
+moviepy/video/fx/freeze.py,sha256=rMNZ-YHcM5pSsLjLV86mpp74kOfjy0avNkw5aXflwwM,1117
+moviepy/video/fx/freeze_region.py,sha256=AQLGDUfOaqxgvhbneK1hrruITPO9e_ymSPnyBVREquo,1921
+moviepy/video/fx/gamma_corr.py,sha256=R57Qpadustr91V2fuH6-9D-GJkrvGWvrc2K80DUpgos,212
+moviepy/video/fx/headblur.py,sha256=_slnQ6EX2llHtR6yYT9E_F626g647t2hLxixxVxz0MQ,1816
+moviepy/video/fx/invert_colors.py,sha256=zJ8GxaICGxLYhUmHOs0_4HqCpVCstoq3GE26ilbE0-k,289
+moviepy/video/fx/loop.py,sha256=2zahdRTzmQTeFvIQOgEYiwD4__0uwbuGiE3QYQEjEWA,727
+moviepy/video/fx/lum_contrast.py,sha256=ET2S1qMd5kEIh5tFpL-sTWxtU6LHGx1jtGw_NW16FeM,406
+moviepy/video/fx/make_loopable.py,sha256=DrfqEj48DH1yxQwEEtFKLzlWtWR21oGqQjOrCwpt_6w,532
+moviepy/video/fx/margin.py,sha256=az1ZIfz3NE67JSCtnrw5RIrL9Z6ADP11tU2BIpr5TNQ,1726
+moviepy/video/fx/mask_and.py,sha256=Pr-osWikjIQp9Re5MT3ufezOL25Ttz8r-KuAAHLlyTU,662
+moviepy/video/fx/mask_color.py,sha256=3ertiUdcgbna8d6rkY7Vo8ylz2ilkegiIGsK0sNAOu8,903
+moviepy/video/fx/mask_or.py,sha256=72oxhZe1jM04JpR0osezDtPvUWb7PJMdr0Sc7diZrcc,666
+moviepy/video/fx/mirror_x.py,sha256=GlRCyuatW7bCgZC0HtrUxKOf2gilhGhf-jT1W3uzPpA,177
+moviepy/video/fx/mirror_y.py,sha256=wY5njXDVmGx8ewVIbDSJ-TXgG1XvE2k0Et8B4lh412E,173
+moviepy/video/fx/painting.py,sha256=KEcbIiqcTGlI3TqAGWhLs48YIO_QgHAQH328-GwaN8Q,1412
+moviepy/video/fx/resize.py,sha256=4iPt0l28IUE1HipdS1D8g90YASHxgi73aM5FDa_Xdp4,4942
+moviepy/video/fx/rotate.py,sha256=oRvXl9yMDTuorfjMDZDY5Sr5c4AMkbE-LMkJo9nnBkE,2195
+moviepy/video/fx/scroll.py,sha256=bXUtgi8OlOLOMkW4CWZUvlArbfjqMjfixtIXuQJnj7I,526
+moviepy/video/fx/speedx.py,sha256=hKUhAWXSsmN8uhM4tPz4P-506jNl_j0hy5gW2F6rSIY,723
+moviepy/video/fx/supersample.py,sha256=W31r8T7uwKQrqx6VTSqsRex7EZViTuuKSCf_0o1ePVg,421
+moviepy/video/fx/time_mirror.py,sha256=-cs7r_XevuoDF1TV7dM7jCmmFhnHwjaXeM2_dV0y7eU,425
+moviepy/video/fx/time_symmetrize.py,sha256=KpKB97vnBheYTrWMaoqbTkZEPniBVb_pt40I2UJw2H8,602
+moviepy/video/io/ImageSequenceClip.py,sha256=H4yZBUmzKXdxUeAlN8lF52sRG3SXgNUp-5geyWEZp78,4956
+moviepy/video/io/VideoFileClip.py,sha256=Z2Qq7MPzu8Ng8ZNkkwUmrBvrabjSfv6nIPrXHQuDu_E,4500
+moviepy/video/io/__init__.py,sha256=f_CLHkRt4wh9sMTfcORcoU_XhM5hYwQF6beNXYxbVAA,77
+moviepy/video/io/__pycache__/ImageSequenceClip.cpython-310.pyc,,
+moviepy/video/io/__pycache__/VideoFileClip.cpython-310.pyc,,
+moviepy/video/io/__pycache__/__init__.cpython-310.pyc,,
+moviepy/video/io/__pycache__/bindings.cpython-310.pyc,,
+moviepy/video/io/__pycache__/downloader.cpython-310.pyc,,
+moviepy/video/io/__pycache__/ffmpeg_reader.cpython-310.pyc,,
+moviepy/video/io/__pycache__/ffmpeg_tools.cpython-310.pyc,,
+moviepy/video/io/__pycache__/ffmpeg_writer.cpython-310.pyc,,
+moviepy/video/io/__pycache__/gif_writers.cpython-310.pyc,,
+moviepy/video/io/__pycache__/html_tools.cpython-310.pyc,,
+moviepy/video/io/__pycache__/preview.cpython-310.pyc,,
+moviepy/video/io/__pycache__/sliders.cpython-310.pyc,,
+moviepy/video/io/bindings.py,sha256=ZPmk4nhs3p9a5UOc0vPAzJqz4r_Dm_8gFMt9UxsSasA,1079
+moviepy/video/io/downloader.py,sha256=Ya8-QGdqMrv_RSkqweNDDOPwFuOmX_U4fPIfUw7u7FI,1054
+moviepy/video/io/ffmpeg_reader.py,sha256=MiLqJ13MMKmgQnuW3S9NUCMBzjKW4bwuRgFFw08S6lA,13326
+moviepy/video/io/ffmpeg_tools.py,sha256=MDoPLL3J7XU-I8_FxFvLG_3DHHQArHAl7Su3TIrO9Y8,2321
+moviepy/video/io/ffmpeg_writer.py,sha256=olpaK8FHdxOf3zIkx72vger9VCtyF80JirtFOm3yz4w,9064
+moviepy/video/io/gif_writers.py,sha256=8MDwrW62IP5inW7hJBkgphWYpxeNa5fPPWwqcGotXhs,8933
+moviepy/video/io/html_tools.py,sha256=8-YCJCClZl0Dfna6elFzXvQrNWWKbv79_XIqvPjHAto,7591
+moviepy/video/io/preview.py,sha256=fcmW6gx4aqFlm6Pdj7GGRlv6-xfP98KnApXi7GRiWuI,4794
+moviepy/video/io/sliders.py,sha256=CcUGXVMnP2kgtdtODs52m9xT7LQdndrhAuHb-X7-q5Y,2116
+moviepy/video/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+moviepy/video/tools/__pycache__/__init__.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/credits.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/cuts.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/drawing.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/interpolators.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/segmenting.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/subtitles.cpython-310.pyc,,
+moviepy/video/tools/__pycache__/tracking.cpython-310.pyc,,
+moviepy/video/tools/credits.py,sha256=8bBkmGZCVdcuXgaXlHHnpQ7ztwWwEe7zFvojam5vJdk,3414
+moviepy/video/tools/cuts.py,sha256=lYFNvXl0fZeU5GwhDO5Eg8ql_VrAHjDelK9B-TQypgM,10757
+moviepy/video/tools/drawing.py,sha256=7obNphKPUGLwyHzsw-KI-3vpVxsv4ZA9rdp507ce5P4,8760
+moviepy/video/tools/interpolators.py,sha256=0ZJItLPf0AKOvPH1quVjQ0nhESrezqK8G_rjq-72vQs,2122
+moviepy/video/tools/segmenting.py,sha256=ELePrd_Zr0uOnpraYww_P5kjCzE_anG2gfnRdQCIf1E,1821
+moviepy/video/tools/subtitles.py,sha256=QgBRfXJ7_GjRARV_NWewBEXjNP5KoKY9ZWbGWUjHHrA,5215
+moviepy/video/tools/tracking.py,sha256=s5TMgCwun1vuLbqZnWrergSKTY4-rYql3WcFcuoZB_E,6066

evalkit_tf437/lib/python3.10/site-packages/moviepy-1.0.3.dist-info/WHEEL

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

evalkit_tf437/lib/python3.10/site-packages/moviepy-1.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+moviepy

evalkit_tf437/lib/python3.10/site-packages/multidict-6.1.0.dist-info/INSTALLER

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

evalkit_tf437/lib/python3.10/site-packages/multidict-6.1.0.dist-info/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2016 Andrew Svetlov and aio-libs contributors
+
+   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/multidict-6.1.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.1
+Name: multidict
+Version: 6.1.0
+Summary: multidict implementation
+Home-page: https://github.com/aio-libs/multidict
+Author: Andrew Svetlov
+Author-email: andrew.svetlov@gmail.com
+License: Apache 2
+Project-URL: Chat: Matrix, https://matrix.to/#/#aio-libs:matrix.org
+Project-URL: Chat: Matrix Space, https://matrix.to/#/#aio-libs-space:matrix.org
+Project-URL: CI: GitHub, https://github.com/aio-libs/multidict/actions
+Project-URL: Code of Conduct, https://github.com/aio-libs/.github/blob/master/CODE_OF_CONDUCT.md
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/multidict
+Project-URL: Docs: Changelog, https://multidict.aio-libs.org/en/latest/changes/
+Project-URL: Docs: RTD, https://multidict.aio-libs.org
+Project-URL: GitHub: issues, https://github.com/aio-libs/multidict/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/multidict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions >=4.1.0 ; python_version < "3.11"
+
+=========
+multidict
+=========
+
+.. image:: https://github.com/aio-libs/multidict/actions/workflows/ci-cd.yml/badge.svg
+   :target: https://github.com/aio-libs/multidict/actions
+   :alt: GitHub status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/multidict/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/multidict
+   :alt: Coverage metrics
+
+.. image:: https://img.shields.io/pypi/v/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: PyPI
+
+.. image:: https://readthedocs.org/projects/multidict/badge/?version=latest
+   :target: https://multidict.aio-libs.org
+   :alt: Read The Docs build status badge
+
+.. image:: https://img.shields.io/pypi/pyversions/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: Python versions
+
+.. image:: https://img.shields.io/matrix/aio-libs:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs:matrix.org
+   :alt: Matrix Room — #aio-libs:matrix.org
+
+.. image:: https://img.shields.io/matrix/aio-libs-space:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs-space%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs-space:matrix.org
+   :alt: Matrix Space — #aio-libs-space:matrix.org
+
+Multidict is dict-like collection of *key-value pairs* where key
+might occur more than once in the container.
+
+Introduction
+------------
+
+*HTTP Headers* and *URL query string* require specific data structure:
+*multidict*. It behaves mostly like a regular ``dict`` but it may have
+several *values* for the same *key* and *preserves insertion ordering*.
+
+The *key* is ``str`` (or ``istr`` for case-insensitive dictionaries).
+
+``multidict`` has four multidict classes:
+``MultiDict``, ``MultiDictProxy``, ``CIMultiDict``
+and ``CIMultiDictProxy``.
+
+Immutable proxies (``MultiDictProxy`` and
+``CIMultiDictProxy``) provide a dynamic view for the
+proxied multidict, the view reflects underlying collection changes. They
+implement the ``collections.abc.Mapping`` interface.
+
+Regular mutable (``MultiDict`` and ``CIMultiDict``) classes
+implement ``collections.abc.MutableMapping`` and allows them to change
+their own content.
+
+
+*Case insensitive* (``CIMultiDict`` and
+``CIMultiDictProxy``) assume the *keys* are case
+insensitive, e.g.::
+
+   >>> dct = CIMultiDict(key='val')
+   >>> 'Key' in dct
+   True
+   >>> dct['Key']
+   'val'
+
+*Keys* should be ``str`` or ``istr`` instances.
+
+The library has optional C Extensions for speed.
+
+
+License
+-------
+
+Apache 2
+
+Library Installation
+--------------------
+
+.. code-block:: bash
+
+   $ pip install multidict
+
+The library is Python 3 only!
+
+PyPI contains binary wheels for Linux, Windows and MacOS.  If you want to install
+``multidict`` on another operating system (or *Alpine Linux* inside a Docker) the
+tarball will be used to compile the library from source.  It requires a C compiler and
+Python headers to be installed.
+
+To skip the compilation, please use the `MULTIDICT_NO_EXTENSIONS` environment variable,
+e.g.:
+
+.. code-block:: bash
+
+   $ MULTIDICT_NO_EXTENSIONS=1 pip install multidict
+
+Please note, the pure Python (uncompiled) version is about 20-50 times slower depending on
+the usage scenario!!!
+
+
+
+Changelog
+---------
+See `RTD page <http://multidict.aio-libs.org/en/latest/changes>`_.

evalkit_tf437/lib/python3.10/site-packages/multidict-6.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+multidict-6.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+multidict-6.1.0.dist-info/LICENSE,sha256=k9Ealo4vDzY3PECBH_bSDhc_WMPKtYhM1mF7v9eVSSo,611
+multidict-6.1.0.dist-info/METADATA,sha256=OnCx5DR4XPf64GIDK4XmcA2e7HLQ_784vMfEQy287kM,4979
+multidict-6.1.0.dist-info/RECORD,,
+multidict-6.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multidict-6.1.0.dist-info/WHEEL,sha256=K6ps4aVUsEay-13wCJy8H3VKOTWNlXTmCBW4TF80uCE,151
+multidict-6.1.0.dist-info/top_level.txt,sha256=-euDElkk5_qkmfIJ7WiqCab02ZlSFZWynejKg59qZQQ,10
+multidict/__init__.py,sha256=p60Ag5UVACSli1txazSi85foCmHN-cg3qZDCuWdOKng,928
+multidict/__init__.pyi,sha256=SbgC2ew1NvNXWlRKs9o0KhW4moozgMqgQ0OA4Re5JQQ,4840
+multidict/__pycache__/__init__.cpython-310.pyc,,
+multidict/__pycache__/_abc.cpython-310.pyc,,
+multidict/__pycache__/_compat.cpython-310.pyc,,
+multidict/__pycache__/_multidict_base.cpython-310.pyc,,
+multidict/__pycache__/_multidict_py.cpython-310.pyc,,
+multidict/_abc.py,sha256=Zvnrn4SBkrv4QTD7-ZzqNcoxw0f8KStLMPzGvBuGT2w,1190
+multidict/_compat.py,sha256=uCNUpVHJSFOiKUJmRcz3SDqMpkb37C_csc29ijr8Evo,352
+multidict/_multidict.cpython-310-x86_64-linux-gnu.so,sha256=PM5Jz9d2OytBpQNf2J2rbDXasWF9b9M4abzFOc3c5xI,394656
+multidict/_multidict_base.py,sha256=ZndtnZ5oc1sODKmXsv6F9kWvVNCda9xAEEFXkaPoFoA,3979
+multidict/_multidict_py.py,sha256=57h4sYrRIu7EjMX4YpHVIZVrV9-q1KCW3F6rao10D3U,15050
+multidict/py.typed,sha256=e9bmbH3UFxsabQrnNFPG9qxIXztwbcM6IKDYnvZwprY,15

evalkit_tf437/lib/python3.10/site-packages/multidict-6.1.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (74.1.2)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

evalkit_tf437/lib/python3.10/site-packages/multidict-6.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+multidict

evalkit_tf437/lib/python3.10/site-packages/pandas/core/__pycache__/generic.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4796c6f77fbf773f140e8d11b56b053aa12f46718e00d67455063c464e6e5507
+size 385660

evalkit_tf437/lib/python3.10/site-packages/pytz/lazy.py

@@ -0,0 +1,172 @@
+from threading import RLock
+try:
+    from collections.abc import Mapping as DictMixin
+except ImportError:  # Python < 3.3
+    try:
+        from UserDict import DictMixin  # Python 2
+    except ImportError:  # Python 3.0-3.3
+        from collections import Mapping as DictMixin
+
+
+# With lazy loading, we might end up with multiple threads triggering
+# it at the same time. We need a lock.
+_fill_lock = RLock()
+
+
+class LazyDict(DictMixin):
+    """Dictionary populated on first use."""
+    data = None
+
+    def __getitem__(self, key):
+        if self.data is None:
+            _fill_lock.acquire()
+            try:
+                if self.data is None:
+                    self._fill()
+            finally:
+                _fill_lock.release()
+        return self.data[key.upper()]
+
+    def __contains__(self, key):
+        if self.data is None:
+            _fill_lock.acquire()
+            try:
+                if self.data is None:
+                    self._fill()
+            finally:
+                _fill_lock.release()
+        return key in self.data
+
+    def __iter__(self):
+        if self.data is None:
+            _fill_lock.acquire()
+            try:
+                if self.data is None:
+                    self._fill()
+            finally:
+                _fill_lock.release()
+        return iter(self.data)
+
+    def __len__(self):
+        if self.data is None:
+            _fill_lock.acquire()
+            try:
+                if self.data is None:
+                    self._fill()
+            finally:
+                _fill_lock.release()
+        return len(self.data)
+
+    def keys(self):
+        if self.data is None:
+            _fill_lock.acquire()
+            try:
+                if self.data is None:
+                    self._fill()
+            finally:
+                _fill_lock.release()
+        return self.data.keys()
+
+
+class LazyList(list):
+    """List populated on first use."""
+
+    _props = [
+        '__str__', '__repr__', '__unicode__',
+        '__hash__', '__sizeof__', '__cmp__',
+        '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__',
+        'append', 'count', 'index', 'extend', 'insert', 'pop', 'remove',
+        'reverse', 'sort', '__add__', '__radd__', '__iadd__', '__mul__',
+        '__rmul__', '__imul__', '__contains__', '__len__', '__nonzero__',
+        '__getitem__', '__setitem__', '__delitem__', '__iter__',
+        '__reversed__', '__getslice__', '__setslice__', '__delslice__']
+
+    def __new__(cls, fill_iter=None):
+
+        if fill_iter is None:
+            return list()
+
+        # We need a new class as we will be dynamically messing with its
+        # methods.
+        class LazyList(list):
+            pass
+
+        fill_iter = [fill_iter]
+
+        def lazy(name):
+            def _lazy(self, *args, **kw):
+                _fill_lock.acquire()
+                try:
+                    if len(fill_iter) > 0:
+                        list.extend(self, fill_iter.pop())
+                        for method_name in cls._props:
+                            delattr(LazyList, method_name)
+                finally:
+                    _fill_lock.release()
+                return getattr(list, name)(self, *args, **kw)
+            return _lazy
+
+        for name in cls._props:
+            setattr(LazyList, name, lazy(name))
+
+        new_list = LazyList()
+        return new_list
+
+# Not all versions of Python declare the same magic methods.
+# Filter out properties that don't exist in this version of Python
+# from the list.
+LazyList._props = [prop for prop in LazyList._props if hasattr(list, prop)]
+
+
+class LazySet(set):
+    """Set populated on first use."""
+
+    _props = (
+        '__str__', '__repr__', '__unicode__',
+        '__hash__', '__sizeof__', '__cmp__',
+        '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__',
+        '__contains__', '__len__', '__nonzero__',
+        '__getitem__', '__setitem__', '__delitem__', '__iter__',
+        '__sub__', '__and__', '__xor__', '__or__',
+        '__rsub__', '__rand__', '__rxor__', '__ror__',
+        '__isub__', '__iand__', '__ixor__', '__ior__',
+        'add', 'clear', 'copy', 'difference', 'difference_update',
+        'discard', 'intersection', 'intersection_update', 'isdisjoint',
+        'issubset', 'issuperset', 'pop', 'remove',
+        'symmetric_difference', 'symmetric_difference_update',
+        'union', 'update')
+
+    def __new__(cls, fill_iter=None):
+
+        if fill_iter is None:
+            return set()
+
+        class LazySet(set):
+            pass
+
+        fill_iter = [fill_iter]
+
+        def lazy(name):
+            def _lazy(self, *args, **kw):
+                _fill_lock.acquire()
+                try:
+                    if len(fill_iter) > 0:
+                        for i in fill_iter.pop():
+                            set.add(self, i)
+                        for method_name in cls._props:
+                            delattr(LazySet, method_name)
+                finally:
+                    _fill_lock.release()
+                return getattr(set, name)(self, *args, **kw)
+            return _lazy
+
+        for name in cls._props:
+            setattr(LazySet, name, lazy(name))
+
+        new_set = LazySet()
+        return new_set
+
+# Not all versions of Python declare the same magic methods.
+# Filter out properties that don't exist in this version of Python
+# from the list.
+LazySet._props = [prop for prop in LazySet._props if hasattr(set, prop)]

evalkit_tf437/lib/python3.10/site-packages/pytz/tzinfo.py

@@ -0,0 +1,580 @@
+'''Base classes and helpers for building zone specific tzinfo classes'''
+
+from datetime import datetime, timedelta, tzinfo
+from bisect import bisect_right
+try:
+    set
+except NameError:
+    from sets import Set as set
+
+import pytz
+from pytz.exceptions import AmbiguousTimeError, NonExistentTimeError
+
+__all__ = []
+
+_timedelta_cache = {}
+
+
+def memorized_timedelta(seconds):
+    '''Create only one instance of each distinct timedelta'''
+    try:
+        return _timedelta_cache[seconds]
+    except KeyError:
+        delta = timedelta(seconds=seconds)
+        _timedelta_cache[seconds] = delta
+        return delta
+
+
+_epoch = datetime(1970, 1, 1, 0, 0) # datetime.utcfromtimestamp(0)
+_datetime_cache = {0: _epoch}
+
+
+def memorized_datetime(seconds):
+    '''Create only one instance of each distinct datetime'''
+    try:
+        return _datetime_cache[seconds]
+    except KeyError:
+        # NB. We can't just do datetime.fromtimestamp(seconds, tz=timezone.utc).replace(tzinfo=None)
+        # as this fails with negative values under Windows (Bug #90096)
+        dt = _epoch + timedelta(seconds=seconds)
+        _datetime_cache[seconds] = dt
+        return dt
+
+
+_ttinfo_cache = {}
+
+
+def memorized_ttinfo(*args):
+    '''Create only one instance of each distinct tuple'''
+    try:
+        return _ttinfo_cache[args]
+    except KeyError:
+        ttinfo = (
+            memorized_timedelta(args[0]),
+            memorized_timedelta(args[1]),
+            args[2]
+        )
+        _ttinfo_cache[args] = ttinfo
+        return ttinfo
+
+
+_notime = memorized_timedelta(0)
+
+
+def _to_seconds(td):
+    '''Convert a timedelta to seconds'''
+    return td.seconds + td.days * 24 * 60 * 60
+
+
+class BaseTzInfo(tzinfo):
+    # Overridden in subclass
+    _utcoffset = None
+    _tzname = None
+    zone = None
+
+    def __str__(self):
+        return self.zone
+
+
+class StaticTzInfo(BaseTzInfo):
+    '''A timezone that has a constant offset from UTC
+
+    These timezones are rare, as most locations have changed their
+    offset at some point in their history
+    '''
+    def fromutc(self, dt):
+        '''See datetime.tzinfo.fromutc'''
+        if dt.tzinfo is not None and dt.tzinfo is not self:
+            raise ValueError('fromutc: dt.tzinfo is not self')
+        return (dt + self._utcoffset).replace(tzinfo=self)
+
+    def utcoffset(self, dt, is_dst=None):
+        '''See datetime.tzinfo.utcoffset
+
+        is_dst is ignored for StaticTzInfo, and exists only to
+        retain compatibility with DstTzInfo.
+        '''
+        return self._utcoffset
+
+    def dst(self, dt, is_dst=None):
+        '''See datetime.tzinfo.dst
+
+        is_dst is ignored for StaticTzInfo, and exists only to
+        retain compatibility with DstTzInfo.
+        '''
+        return _notime
+
+    def tzname(self, dt, is_dst=None):
+        '''See datetime.tzinfo.tzname
+
+        is_dst is ignored for StaticTzInfo, and exists only to
+        retain compatibility with DstTzInfo.
+        '''
+        return self._tzname
+
+    def localize(self, dt, is_dst=False):
+        '''Convert naive time to local time'''
+        if dt.tzinfo is not None:
+            raise ValueError('Not naive datetime (tzinfo is already set)')
+        return dt.replace(tzinfo=self)
+
+    def normalize(self, dt, is_dst=False):
+        '''Correct the timezone information on the given datetime.
+
+        This is normally a no-op, as StaticTzInfo timezones never have
+        ambiguous cases to correct:
+
+        >>> from pytz import timezone
+        >>> gmt = timezone('GMT')
+        >>> isinstance(gmt, StaticTzInfo)
+        True
+        >>> dt = datetime(2011, 5, 8, 1, 2, 3, tzinfo=gmt)
+        >>> gmt.normalize(dt) is dt
+        True
+
+        The supported method of converting between timezones is to use
+        datetime.astimezone(). Currently normalize() also works:
+
+        >>> la = timezone('America/Los_Angeles')
+        >>> dt = la.localize(datetime(2011, 5, 7, 1, 2, 3))
+        >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
+        >>> gmt.normalize(dt).strftime(fmt)
+        '2011-05-07 08:02:03 GMT (+0000)'
+        '''
+        if dt.tzinfo is self:
+            return dt
+        if dt.tzinfo is None:
+            raise ValueError('Naive time - no tzinfo set')
+        return dt.astimezone(self)
+
+    def __repr__(self):
+        return '<StaticTzInfo %r>' % (self.zone,)
+
+    def __reduce__(self):
+        # Special pickle to zone remains a singleton and to cope with
+        # database changes.
+        return pytz._p, (self.zone,)
+
+
+class DstTzInfo(BaseTzInfo):
+    '''A timezone that has a variable offset from UTC
+
+    The offset might change if daylight saving time comes into effect,
+    or at a point in history when the region decides to change their
+    timezone definition.
+    '''
+    # Overridden in subclass
+
+    # Sorted list of DST transition times, UTC
+    _utc_transition_times = None
+
+    # [(utcoffset, dstoffset, tzname)] corresponding to
+    # _utc_transition_times entries
+    _transition_info = None
+
+    zone = None
+
+    # Set in __init__
+
+    _tzinfos = None
+    _dst = None  # DST offset
+
+    def __init__(self, _inf=None, _tzinfos=None):
+        if _inf:
+            self._tzinfos = _tzinfos
+            self._utcoffset, self._dst, self._tzname = _inf
+        else:
+            _tzinfos = {}
+            self._tzinfos = _tzinfos
+            self._utcoffset, self._dst, self._tzname = (
+                self._transition_info[0])
+            _tzinfos[self._transition_info[0]] = self
+            for inf in self._transition_info[1:]:
+                if inf not in _tzinfos:
+                    _tzinfos[inf] = self.__class__(inf, _tzinfos)
+
+    def fromutc(self, dt):
+        '''See datetime.tzinfo.fromutc'''
+        if (dt.tzinfo is not None and
+                getattr(dt.tzinfo, '_tzinfos', None) is not self._tzinfos):
+            raise ValueError('fromutc: dt.tzinfo is not self')
+        dt = dt.replace(tzinfo=None)
+        idx = max(0, bisect_right(self._utc_transition_times, dt) - 1)
+        inf = self._transition_info[idx]
+        return (dt + inf[0]).replace(tzinfo=self._tzinfos[inf])
+
+    def normalize(self, dt):
+        '''Correct the timezone information on the given datetime
+
+        If date arithmetic crosses DST boundaries, the tzinfo
+        is not magically adjusted. This method normalizes the
+        tzinfo to the correct one.
+
+        To test, first we need to do some setup
+
+        >>> from pytz import timezone
+        >>> utc = timezone('UTC')
+        >>> eastern = timezone('US/Eastern')
+        >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
+
+        We next create a datetime right on an end-of-DST transition point,
+        the instant when the wallclocks are wound back one hour.
+
+        >>> utc_dt = datetime(2002, 10, 27, 6, 0, 0, tzinfo=utc)
+        >>> loc_dt = utc_dt.astimezone(eastern)
+        >>> loc_dt.strftime(fmt)
+        '2002-10-27 01:00:00 EST (-0500)'
+
+        Now, if we subtract a few minutes from it, note that the timezone
+        information has not changed.
+
+        >>> before = loc_dt - timedelta(minutes=10)
+        >>> before.strftime(fmt)
+        '2002-10-27 00:50:00 EST (-0500)'
+
+        But we can fix that by calling the normalize method
+
+        >>> before = eastern.normalize(before)
+        >>> before.strftime(fmt)
+        '2002-10-27 01:50:00 EDT (-0400)'
+
+        The supported method of converting between timezones is to use
+        datetime.astimezone(). Currently, normalize() also works:
+
+        >>> th = timezone('Asia/Bangkok')
+        >>> am = timezone('Europe/Amsterdam')
+        >>> dt = th.localize(datetime(2011, 5, 7, 1, 2, 3))
+        >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
+        >>> am.normalize(dt).strftime(fmt)
+        '2011-05-06 20:02:03 CEST (+0200)'
+        '''
+        if dt.tzinfo is None:
+            raise ValueError('Naive time - no tzinfo set')
+
+        # Convert dt in localtime to UTC
+        offset = dt.tzinfo._utcoffset
+        dt = dt.replace(tzinfo=None)
+        dt = dt - offset
+        # convert it back, and return it
+        return self.fromutc(dt)
+
+    def localize(self, dt, is_dst=False):
+        '''Convert naive time to local time.
+
+        This method should be used to construct localtimes, rather
+        than passing a tzinfo argument to a datetime constructor.
+
+        is_dst is used to determine the correct timezone in the ambigous
+        period at the end of daylight saving time.
+
+        >>> from pytz import timezone
+        >>> fmt = '%Y-%m-%d %H:%M:%S %Z (%z)'
+        >>> amdam = timezone('Europe/Amsterdam')
+        >>> dt  = datetime(2004, 10, 31, 2, 0, 0)
+        >>> loc_dt1 = amdam.localize(dt, is_dst=True)
+        >>> loc_dt2 = amdam.localize(dt, is_dst=False)
+        >>> loc_dt1.strftime(fmt)
+        '2004-10-31 02:00:00 CEST (+0200)'
+        >>> loc_dt2.strftime(fmt)
+        '2004-10-31 02:00:00 CET (+0100)'
+        >>> str(loc_dt2 - loc_dt1)
+        '1:00:00'
+
+        Use is_dst=None to raise an AmbiguousTimeError for ambiguous
+        times at the end of daylight saving time
+
+        >>> try:
+        ...     loc_dt1 = amdam.localize(dt, is_dst=None)
+        ... except AmbiguousTimeError:
+        ...     print('Ambiguous')
+        Ambiguous
+
+        is_dst defaults to False
+
+        >>> amdam.localize(dt) == amdam.localize(dt, False)
+        True
+
+        is_dst is also used to determine the correct timezone in the
+        wallclock times jumped over at the start of daylight saving time.
+
+        >>> pacific = timezone('US/Pacific')
+        >>> dt = datetime(2008, 3, 9, 2, 0, 0)
+        >>> ploc_dt1 = pacific.localize(dt, is_dst=True)
+        >>> ploc_dt2 = pacific.localize(dt, is_dst=False)
+        >>> ploc_dt1.strftime(fmt)
+        '2008-03-09 02:00:00 PDT (-0700)'
+        >>> ploc_dt2.strftime(fmt)
+        '2008-03-09 02:00:00 PST (-0800)'
+        >>> str(ploc_dt2 - ploc_dt1)
+        '1:00:00'
+
+        Use is_dst=None to raise a NonExistentTimeError for these skipped
+        times.
+
+        >>> try:
+        ...     loc_dt1 = pacific.localize(dt, is_dst=None)
+        ... except NonExistentTimeError:
+        ...     print('Non-existent')
+        Non-existent
+        '''
+        if dt.tzinfo is not None:
+            raise ValueError('Not naive datetime (tzinfo is already set)')
+
+        # Find the two best possibilities.
+        possible_loc_dt = set()
+        for delta in [timedelta(days=-1), timedelta(days=1)]:
+            loc_dt = dt + delta
+            idx = max(0, bisect_right(
+                self._utc_transition_times, loc_dt) - 1)
+            inf = self._transition_info[idx]
+            tzinfo = self._tzinfos[inf]
+            loc_dt = tzinfo.normalize(dt.replace(tzinfo=tzinfo))
+            if loc_dt.replace(tzinfo=None) == dt:
+                possible_loc_dt.add(loc_dt)
+
+        if len(possible_loc_dt) == 1:
+            return possible_loc_dt.pop()
+
+        # If there are no possibly correct timezones, we are attempting
+        # to convert a time that never happened - the time period jumped
+        # during the start-of-DST transition period.
+        if len(possible_loc_dt) == 0:
+            # If we refuse to guess, raise an exception.
+            if is_dst is None:
+                raise NonExistentTimeError(dt)
+
+            # If we are forcing the pre-DST side of the DST transition, we
+            # obtain the correct timezone by winding the clock forward a few
+            # hours.
+            elif is_dst:
+                return self.localize(
+                    dt + timedelta(hours=6), is_dst=True) - timedelta(hours=6)
+
+            # If we are forcing the post-DST side of the DST transition, we
+            # obtain the correct timezone by winding the clock back.
+            else:
+                return self.localize(
+                    dt - timedelta(hours=6),
+                    is_dst=False) + timedelta(hours=6)
+
+        # If we get this far, we have multiple possible timezones - this
+        # is an ambiguous case occurring during the end-of-DST transition.
+
+        # If told to be strict, raise an exception since we have an
+        # ambiguous case
+        if is_dst is None:
+            raise AmbiguousTimeError(dt)
+
+        # Filter out the possiblilities that don't match the requested
+        # is_dst
+        filtered_possible_loc_dt = [
+            p for p in possible_loc_dt if bool(p.tzinfo._dst) == is_dst
+        ]
+
+        # Hopefully we only have one possibility left. Return it.
+        if len(filtered_possible_loc_dt) == 1:
+            return filtered_possible_loc_dt[0]
+
+        if len(filtered_possible_loc_dt) == 0:
+            filtered_possible_loc_dt = list(possible_loc_dt)
+
+        # If we get this far, we have in a wierd timezone transition
+        # where the clocks have been wound back but is_dst is the same
+        # in both (eg. Europe/Warsaw 1915 when they switched to CET).
+        # At this point, we just have to guess unless we allow more
+        # hints to be passed in (such as the UTC offset or abbreviation),
+        # but that is just getting silly.
+        #
+        # Choose the earliest (by UTC) applicable timezone if is_dst=True
+        # Choose the latest (by UTC) applicable timezone if is_dst=False
+        # i.e., behave like end-of-DST transition
+        dates = {}  # utc -> local
+        for local_dt in filtered_possible_loc_dt:
+            utc_time = (
+                local_dt.replace(tzinfo=None) - local_dt.tzinfo._utcoffset)
+            assert utc_time not in dates
+            dates[utc_time] = local_dt
+        return dates[[min, max][not is_dst](dates)]
+
+    def utcoffset(self, dt, is_dst=None):
+        '''See datetime.tzinfo.utcoffset
+
+        The is_dst parameter may be used to remove ambiguity during DST
+        transitions.
+
+        >>> from pytz import timezone
+        >>> tz = timezone('America/St_Johns')
+        >>> ambiguous = datetime(2009, 10, 31, 23, 30)
+
+        >>> str(tz.utcoffset(ambiguous, is_dst=False))
+        '-1 day, 20:30:00'
+
+        >>> str(tz.utcoffset(ambiguous, is_dst=True))
+        '-1 day, 21:30:00'
+
+        >>> try:
+        ...     tz.utcoffset(ambiguous)
+        ... except AmbiguousTimeError:
+        ...     print('Ambiguous')
+        Ambiguous
+
+        '''
+        if dt is None:
+            return None
+        elif dt.tzinfo is not self:
+            dt = self.localize(dt, is_dst)
+            return dt.tzinfo._utcoffset
+        else:
+            return self._utcoffset
+
+    def dst(self, dt, is_dst=None):
+        '''See datetime.tzinfo.dst
+
+        The is_dst parameter may be used to remove ambiguity during DST
+        transitions.
+
+        >>> from pytz import timezone
+        >>> tz = timezone('America/St_Johns')
+
+        >>> normal = datetime(2009, 9, 1)
+
+        >>> str(tz.dst(normal))
+        '1:00:00'
+        >>> str(tz.dst(normal, is_dst=False))
+        '1:00:00'
+        >>> str(tz.dst(normal, is_dst=True))
+        '1:00:00'
+
+        >>> ambiguous = datetime(2009, 10, 31, 23, 30)
+
+        >>> str(tz.dst(ambiguous, is_dst=False))
+        '0:00:00'
+        >>> str(tz.dst(ambiguous, is_dst=True))
+        '1:00:00'
+        >>> try:
+        ...     tz.dst(ambiguous)
+        ... except AmbiguousTimeError:
+        ...     print('Ambiguous')
+        Ambiguous
+
+        '''
+        if dt is None:
+            return None
+        elif dt.tzinfo is not self:
+            dt = self.localize(dt, is_dst)
+            return dt.tzinfo._dst
+        else:
+            return self._dst
+
+    def tzname(self, dt, is_dst=None):
+        '''See datetime.tzinfo.tzname
+
+        The is_dst parameter may be used to remove ambiguity during DST
+        transitions.
+
+        >>> from pytz import timezone
+        >>> tz = timezone('America/St_Johns')
+
+        >>> normal = datetime(2009, 9, 1)
+
+        >>> tz.tzname(normal)
+        'NDT'
+        >>> tz.tzname(normal, is_dst=False)
+        'NDT'
+        >>> tz.tzname(normal, is_dst=True)
+        'NDT'
+
+        >>> ambiguous = datetime(2009, 10, 31, 23, 30)
+
+        >>> tz.tzname(ambiguous, is_dst=False)
+        'NST'
+        >>> tz.tzname(ambiguous, is_dst=True)
+        'NDT'
+        >>> try:
+        ...     tz.tzname(ambiguous)
+        ... except AmbiguousTimeError:
+        ...     print('Ambiguous')
+        Ambiguous
+        '''
+        if dt is None:
+            return self.zone
+        elif dt.tzinfo is not self:
+            dt = self.localize(dt, is_dst)
+            return dt.tzinfo._tzname
+        else:
+            return self._tzname
+
+    def __repr__(self):
+        if self._dst:
+            dst = 'DST'
+        else:
+            dst = 'STD'
+        if self._utcoffset > _notime:
+            return '<DstTzInfo %r %s+%s %s>' % (
+                self.zone, self._tzname, self._utcoffset, dst
+            )
+        else:
+            return '<DstTzInfo %r %s%s %s>' % (
+                self.zone, self._tzname, self._utcoffset, dst
+            )
+
+    def __reduce__(self):
+        # Special pickle to zone remains a singleton and to cope with
+        # database changes.
+        return pytz._p, (
+            self.zone,
+            _to_seconds(self._utcoffset),
+            _to_seconds(self._dst),
+            self._tzname
+        )
+
+
+def unpickler(zone, utcoffset=None, dstoffset=None, tzname=None):
+    """Factory function for unpickling pytz tzinfo instances.
+
+    This is shared for both StaticTzInfo and DstTzInfo instances, because
+    database changes could cause a zones implementation to switch between
+    these two base classes and we can't break pickles on a pytz version
+    upgrade.
+    """
+    # Raises a KeyError if zone no longer exists, which should never happen
+    # and would be a bug.
+    tz = pytz.timezone(zone)
+
+    # A StaticTzInfo - just return it
+    if utcoffset is None:
+        return tz
+
+    # This pickle was created from a DstTzInfo. We need to
+    # determine which of the list of tzinfo instances for this zone
+    # to use in order to restore the state of any datetime instances using
+    # it correctly.
+    utcoffset = memorized_timedelta(utcoffset)
+    dstoffset = memorized_timedelta(dstoffset)
+    try:
+        return tz._tzinfos[(utcoffset, dstoffset, tzname)]
+    except KeyError:
+        # The particular state requested in this timezone no longer exists.
+        # This indicates a corrupt pickle, or the timezone database has been
+        # corrected violently enough to make this particular
+        # (utcoffset,dstoffset) no longer exist in the zone, or the
+        # abbreviation has been changed.
+        pass
+
+    # See if we can find an entry differing only by tzname. Abbreviations
+    # get changed from the initial guess by the database maintainers to
+    # match reality when this information is discovered.
+    for localized_tz in tz._tzinfos.values():
+        if (localized_tz._utcoffset == utcoffset and
+                localized_tz._dst == dstoffset):
+            return localized_tz
+
+    # This (utcoffset, dstoffset) information has been removed from the
+    # zone. Add it back. This might occur when the database maintainers have
+    # corrected incorrect information. datetime instances using this
+    # incorrect information will continue to do so, exactly as they were
+    # before being pickled. This is purely an overly paranoid safety net - I
+    # doubt this will ever been needed in real life.
+    inf = (utcoffset, dstoffset, tzname)
+    tz._tzinfos[inf] = tz.__class__(inf, tz._tzinfos)
+    return tz._tzinfos[inf]

evalkit_tf437/lib/python3.10/site-packages/scipy/linalg/cython_lapack.cpython-310-x86_64-linux-gnu.so

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