Add files using upload-large-folder tool

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/click/__init__.py

@@ -0,0 +1,126 @@
+"""
+Click is a simple Python module inspired by the stdlib optparse to make
+writing command line scripts fun. Unlike other modules, it's based
+around a simple API that does not come with too much magic and is
+composable.
+"""
+
+from __future__ import annotations
+
+from .core import Argument as Argument
+from .core import Command as Command
+from .core import CommandCollection as CommandCollection
+from .core import Context as Context
+from .core import Group as Group
+from .core import Option as Option
+from .core import Parameter as Parameter
+from .core import ParameterSource as ParameterSource
+from .decorators import argument as argument
+from .decorators import command as command
+from .decorators import confirmation_option as confirmation_option
+from .decorators import group as group
+from .decorators import help_option as help_option
+from .decorators import make_pass_decorator as make_pass_decorator
+from .decorators import option as option
+from .decorators import pass_context as pass_context
+from .decorators import pass_obj as pass_obj
+from .decorators import password_option as password_option
+from .decorators import version_option as version_option
+from .exceptions import Abort as Abort
+from .exceptions import BadArgumentUsage as BadArgumentUsage
+from .exceptions import BadOptionUsage as BadOptionUsage
+from .exceptions import BadParameter as BadParameter
+from .exceptions import ClickException as ClickException
+from .exceptions import FileError as FileError
+from .exceptions import MissingParameter as MissingParameter
+from .exceptions import NoSuchCommand as NoSuchCommand
+from .exceptions import NoSuchOption as NoSuchOption
+from .exceptions import UsageError as UsageError
+from .formatting import HelpFormatter as HelpFormatter
+from .formatting import wrap_text as wrap_text
+from .globals import get_current_context as get_current_context
+from .termui import clear as clear
+from .termui import confirm as confirm
+from .termui import echo_via_pager as echo_via_pager
+from .termui import edit as edit
+from .termui import get_pager_file as get_pager_file
+from .termui import getchar as getchar
+from .termui import launch as launch
+from .termui import pause as pause
+from .termui import progressbar as progressbar
+from .termui import prompt as prompt
+from .termui import secho as secho
+from .termui import style as style
+from .termui import unstyle as unstyle
+from .types import BOOL as BOOL
+from .types import Choice as Choice
+from .types import DateTime as DateTime
+from .types import File as File
+from .types import FLOAT as FLOAT
+from .types import FloatRange as FloatRange
+from .types import INT as INT
+from .types import IntRange as IntRange
+from .types import ParamType as ParamType
+from .types import Path as Path
+from .types import STRING as STRING
+from .types import Tuple as Tuple
+from .types import UNPROCESSED as UNPROCESSED
+from .types import UUID as UUID
+from .utils import echo as echo
+from .utils import format_filename as format_filename
+from .utils import get_app_dir as get_app_dir
+from .utils import get_binary_stream as get_binary_stream
+from .utils import get_text_stream as get_text_stream
+from .utils import open_file as open_file
+
+
+def __getattr__(name: str) -> object:
+    import warnings
+
+    if name == "BaseCommand":
+        from .core import _BaseCommand
+
+        warnings.warn(
+            "'BaseCommand' is deprecated and will be removed in Click 9.0. Use"
+            " 'Command' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _BaseCommand
+
+    if name == "MultiCommand":
+        from .core import _MultiCommand
+
+        warnings.warn(
+            "'MultiCommand' is deprecated and will be removed in Click 9.0. Use"
+            " 'Group' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _MultiCommand
+
+    if name == "OptionParser":
+        from .parser import _OptionParser
+
+        warnings.warn(
+            "'OptionParser' is deprecated and will be removed in Click 9.0. The"
+            " old parser is available in 'optparse'.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _OptionParser
+
+    if name == "__version__":
+        import importlib.metadata
+        import warnings
+
+        warnings.warn(
+            "The '__version__' attribute is deprecated and will be removed in"
+            " Click 9.1. Use feature detection or"
+            " 'importlib.metadata.version(\"click\")' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return importlib.metadata.version("click")
+
+    raise AttributeError(name)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/click/decorators.py

@@ -0,0 +1,551 @@
+from __future__ import annotations
+
+import inspect
+import typing as t
+from functools import update_wrapper
+from gettext import gettext as _
+
+from .core import Argument
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .globals import get_current_context
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    P = te.ParamSpec("P")
+
+R = t.TypeVar("R")
+T = t.TypeVar("T")
+_AnyCallable = t.Callable[..., t.Any]
+FC = t.TypeVar("FC", bound="_AnyCallable | Command")
+
+
+def pass_context(f: t.Callable[te.Concatenate[Context, P], R]) -> t.Callable[P, R]:
+    """Marks a callback as wanting to receive the current context
+    object as first argument.
+    """
+
+    def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(get_current_context(), *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def pass_obj(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, R]:
+    """Similar to :func:`pass_context`, but only pass the object on the
+    context onwards (:attr:`Context.obj`).  This is useful if that object
+    represents the state of a nested system.
+    """
+
+    def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(get_current_context().obj, *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def make_pass_decorator(
+    object_type: type[T], ensure: bool = False
+) -> t.Callable[[t.Callable[te.Concatenate[T, P], R]], t.Callable[P, R]]:
+    """Given an object type this creates a decorator that will work
+    similar to :func:`pass_obj` but instead of passing the object of the
+    current context, it will find the innermost context of type
+    :func:`object_type`.
+
+    This generates a decorator that works roughly like this::
+
+        from functools import update_wrapper
+
+        def decorator(f):
+            @pass_context
+            def new_func(ctx, *args, **kwargs):
+                obj = ctx.find_object(object_type)
+                return ctx.invoke(f, obj, *args, **kwargs)
+            return update_wrapper(new_func, f)
+        return decorator
+
+    :param object_type: the type of the object to pass.
+    :param ensure: if set to `True`, a new object will be created and
+                   remembered on the context if it's not there yet.
+    """
+
+    def decorator(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, R]:
+        def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+            ctx = get_current_context()
+
+            obj: T | None
+            if ensure:
+                obj = ctx.ensure_object(object_type)
+            else:
+                obj = ctx.find_object(object_type)
+
+            if obj is None:
+                raise RuntimeError(
+                    "Managed to invoke callback without a context"
+                    f" object of type {object_type.__name__!r}"
+                    " existing."
+                )
+
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(new_func, f)
+
+    return decorator
+
+
+def pass_meta_key(
+    key: str, *, doc_description: str | None = None
+) -> t.Callable[[t.Callable[te.Concatenate[T, P], R]], t.Callable[P, R]]:
+    """Create a decorator that passes a key from
+    :attr:`click.Context.meta` as the first argument to the decorated
+    function.
+
+    :param key: Key in ``Context.meta`` to pass.
+    :param doc_description: Description of the object being passed,
+        inserted into the decorator's docstring. Defaults to "the 'key'
+        key from Context.meta".
+
+    .. versionadded:: 8.0
+    """
+
+    def decorator(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, R]:
+        def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+            ctx = get_current_context()
+            obj = ctx.meta[key]
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(new_func, f)
+
+    if doc_description is None:
+        doc_description = f"the {key!r} key from :attr:`click.Context.meta`"
+
+    decorator.__doc__ = (
+        f"Decorator that passes {doc_description} as the first argument"
+        " to the decorated function."
+    )
+    return decorator
+
+
+CmdType = t.TypeVar("CmdType", bound=Command)
+
+
+# variant: no call, directly as decorator for a function.
+@t.overload
+def command(name: _AnyCallable) -> Command: ...
+
+
+# variant: with positional name and with positional or keyword cls argument:
+# @command(namearg, CommandCls, ...) or @command(namearg, cls=CommandCls, ...)
+@t.overload
+def command(
+    name: str | None,
+    cls: type[CmdType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], CmdType]: ...
+
+
+# variant: name omitted, cls _must_ be a keyword argument, @command(cls=CommandCls, ...)
+@t.overload
+def command(
+    name: None = None,
+    *,
+    cls: type[CmdType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], CmdType]: ...
+
+
+# variant: with optional string name, no cls argument provided.
+@t.overload
+def command(
+    name: str | None = ..., cls: None = None, **attrs: t.Any
+) -> t.Callable[[_AnyCallable], Command]: ...
+
+
+def command(
+    name: str | _AnyCallable | None = None,
+    cls: type[CmdType] | None = None,
+    **attrs: t.Any,
+) -> Command | t.Callable[[_AnyCallable], Command | CmdType]:
+    r"""Creates a new :class:`Command` and uses the decorated function as
+    callback.  This will also automatically attach all decorated
+    :func:`option`\s and :func:`argument`\s as parameters to the command.
+
+    The name of the command defaults to the name of the function, converted to
+    lowercase, with underscores ``_`` replaced by dashes ``-``, and the suffixes
+    ``_command``, ``_cmd``, ``_group``, and ``_grp`` are removed. For example,
+    ``init_data_command`` becomes ``init-data``.
+
+    All keyword arguments are forwarded to the underlying command class.
+    For the ``params`` argument, any decorated params are appended to
+    the end of the list.
+
+    Once decorated the function turns into a :class:`Command` instance
+    that can be invoked as a command line utility or be attached to a
+    command :class:`Group`.
+
+    :param name: The name of the command. Defaults to modifying the function's
+        name as described above.
+    :param cls: The command class to create. Defaults to :class:`Command`.
+
+    .. versionchanged:: 8.2
+        The suffixes ``_command``, ``_cmd``, ``_group``, and ``_grp`` are
+        removed when generating the name.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+
+    .. versionchanged:: 8.1
+        The ``params`` argument can be used. Decorated params are
+        appended to the end of the list.
+    """
+
+    func: t.Callable[[_AnyCallable], t.Any] | None = None
+
+    if callable(name):
+        func = name
+        name = None
+        assert cls is None, "Use 'command(cls=cls)(callable)' to specify a class."
+        assert not attrs, "Use 'command(**kwargs)(callable)' to provide arguments."
+
+    if cls is None:
+        cls = t.cast("type[CmdType]", Command)
+
+    def decorator(f: _AnyCallable) -> CmdType:
+        if isinstance(f, Command):
+            raise TypeError("Attempted to convert a callback into a command twice.")
+
+        attr_params = attrs.pop("params", None)
+        params = attr_params if attr_params is not None else []
+
+        try:
+            decorator_params = f.__click_params__  # type: ignore
+        except AttributeError:
+            pass
+        else:
+            del f.__click_params__  # type: ignore
+            params.extend(reversed(decorator_params))
+
+        if attrs.get("help") is None:
+            attrs["help"] = f.__doc__
+
+        if t.TYPE_CHECKING:
+            assert cls is not None
+            assert not callable(name)
+
+        if name is not None:
+            cmd_name = name
+        else:
+            cmd_name = f.__name__.lower().replace("_", "-")
+            cmd_left, sep, suffix = cmd_name.rpartition("-")
+
+            if sep and suffix in {"command", "cmd", "group", "grp"}:
+                cmd_name = cmd_left
+
+        cmd = cls(name=cmd_name, callback=f, params=params, **attrs)
+        cmd.__doc__ = f.__doc__
+        return cmd
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+GrpType = t.TypeVar("GrpType", bound=Group)
+
+
+# variant: no call, directly as decorator for a function.
+@t.overload
+def group(name: _AnyCallable) -> Group: ...
+
+
+# variant: with positional name and with positional or keyword cls argument:
+# @group(namearg, GroupCls, ...) or @group(namearg, cls=GroupCls, ...)
+@t.overload
+def group(
+    name: str | None,
+    cls: type[GrpType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], GrpType]: ...
+
+
+# variant: name omitted, cls _must_ be a keyword argument, @group(cmd=GroupCls, ...)
+@t.overload
+def group(
+    name: None = None,
+    *,
+    cls: type[GrpType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], GrpType]: ...
+
+
+# variant: with optional string name, no cls argument provided.
+@t.overload
+def group(
+    name: str | None = ..., cls: None = None, **attrs: t.Any
+) -> t.Callable[[_AnyCallable], Group]: ...
+
+
+def group(
+    name: str | _AnyCallable | None = None,
+    cls: type[GrpType] | None = None,
+    **attrs: t.Any,
+) -> Group | t.Callable[[_AnyCallable], Group | GrpType]:
+    """Creates a new :class:`Group` with a function as callback.  This
+    works otherwise the same as :func:`command` just that the `cls`
+    parameter is set to :class:`Group`.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+    """
+    if cls is None:
+        cls = t.cast("type[GrpType]", Group)
+
+    if callable(name):
+        return command(cls=cls, **attrs)(name)
+
+    return command(name, cls, **attrs)
+
+
+def _param_memo(f: t.Callable[..., t.Any], param: Parameter) -> None:
+    if isinstance(f, Command):
+        f.params.append(param)
+    else:
+        if not hasattr(f, "__click_params__"):
+            f.__click_params__ = []  # type: ignore
+
+        f.__click_params__.append(param)  # type: ignore
+
+
+def argument(
+    *param_decls: str, cls: type[Argument] | None = None, **attrs: t.Any
+) -> t.Callable[[FC], FC]:
+    """Attaches an argument to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Argument`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Argument` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    For the default argument class, refer to :class:`Argument` and
+    :class:`Parameter` for descriptions of parameters.
+
+    :param cls: the argument class to instantiate.  This defaults to
+                :class:`Argument`.
+    :param param_decls: Passed as positional arguments to the constructor of
+        ``cls``.
+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
+    """
+    if cls is None:
+        cls = Argument
+
+    def decorator(f: FC) -> FC:
+        _param_memo(f, cls(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def option(
+    *param_decls: str, cls: type[Option] | None = None, **attrs: t.Any
+) -> t.Callable[[FC], FC]:
+    """Attaches an option to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Option`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Option` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    For the default option class, refer to :class:`Option` and
+    :class:`Parameter` for descriptions of parameters.
+
+    :param cls: the option class to instantiate.  This defaults to
+                :class:`Option`.
+    :param param_decls: Passed as positional arguments to the constructor of
+        ``cls``.
+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
+    """
+    if cls is None:
+        cls = Option
+
+    def decorator(f: FC) -> FC:
+        _param_memo(f, cls(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def confirmation_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--yes`` option which shows a prompt before continuing if
+    not passed. If the prompt is declined, the program will exit.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--yes"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value:
+            ctx.abort()
+
+    if not param_decls:
+        param_decls = ("--yes",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("callback", callback)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("prompt", _("Do you want to continue?"))
+    kwargs.setdefault("help", _("Confirm the action without prompting."))
+    return option(*param_decls, **kwargs)
+
+
+def password_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--password`` option which prompts for a password, hiding
+    input and asking to enter the value again for confirmation.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--password"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+    if not param_decls:
+        param_decls = ("--password",)
+
+    kwargs.setdefault("prompt", True)
+    kwargs.setdefault("confirmation_prompt", True)
+    kwargs.setdefault("hide_input", True)
+    return option(*param_decls, **kwargs)
+
+
+def version_option(
+    version: str | None = None,
+    *param_decls: str,
+    package_name: str | None = None,
+    prog_name: str | None = None,
+    message: str | None = None,
+    **kwargs: t.Any,
+) -> t.Callable[[FC], FC]:
+    """Add a ``--version`` option which immediately prints the version
+    number and exits the program.
+
+    If ``version`` is not provided, Click will try to detect it using
+    :func:`importlib.metadata.version` to get the version for the
+    ``package_name``.
+
+    If ``package_name`` is not provided, Click will try to detect it by
+    inspecting the stack frames. This will be used to detect the
+    version, so it must match the name of the installed package.
+
+    :param version: The version number to show. If not provided, Click
+        will try to detect it.
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--version"``.
+    :param package_name: The package name to detect the version from. If
+        not provided, Click will try to detect it.
+    :param prog_name: The name of the CLI to show in the message. If not
+        provided, it will be detected from the command.
+    :param message: The message to show. The values ``%(prog)s``,
+        ``%(package)s``, and ``%(version)s`` are available. Defaults to
+        ``"%(prog)s, version %(version)s"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    :raise RuntimeError: ``version`` could not be detected.
+
+    .. versionchanged:: 8.0
+        Add the ``package_name`` parameter, and the ``%(package)s``
+        value for messages.
+
+    .. versionchanged:: 8.0
+        Use :mod:`importlib.metadata` instead of ``pkg_resources``. The
+        version is detected based on the package name, not the entry
+        point name. The Python package name must match the installed
+        package name, or be passed with ``package_name=``.
+    """
+    if message is None:
+        message = _("%(prog)s, version %(version)s")
+
+    if version is None and package_name is None:
+        frame = inspect.currentframe()
+        f_back = frame.f_back if frame is not None else None
+        f_globals = f_back.f_globals if f_back is not None else None
+        # break reference cycle
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+        if f_globals is not None:
+            package_name = f_globals.get("__name__")
+
+            if package_name == "__main__":
+                package_name = f_globals.get("__package__")
+
+            if package_name:
+                package_name = package_name.partition(".")[0]
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+
+        nonlocal prog_name
+        nonlocal version
+
+        if prog_name is None:
+            prog_name = ctx.find_root().info_name
+
+        if version is None and package_name is not None:
+            import importlib.metadata
+
+            try:
+                version = importlib.metadata.version(package_name)
+            except importlib.metadata.PackageNotFoundError:
+                raise RuntimeError(
+                    f"{package_name!r} is not installed. Try passing"
+                    " 'package_name' instead."
+                ) from None
+
+        if version is None:
+            raise RuntimeError(
+                f"Could not determine the version for {package_name!r} automatically."
+            )
+
+        echo(
+            message % {"prog": prog_name, "package": package_name, "version": version},
+            color=ctx.color,
+        )
+        ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--version",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show the version and exit."))
+    kwargs["callback"] = callback
+    return option(*param_decls, **kwargs)
+
+
+def help_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Pre-configured ``--help`` option which immediately prints the help page
+    and exits the program.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--help"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def show_help(ctx: Context, param: Parameter, value: bool) -> None:
+        """Callback that print the help page on ``<stdout>`` and exits."""
+        if value and not ctx.resilient_parsing:
+            echo(ctx.get_help(), color=ctx.color)
+            ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--help",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show this message and exit."))
+    kwargs.setdefault("callback", show_help)
+
+    return option(*param_decls, **kwargs)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/click/globals.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import typing as t
+from threading import local
+
+if t.TYPE_CHECKING:
+    from .core import Context
+
+_local = local()
+
+
+@t.overload
+def get_current_context(silent: t.Literal[False] = False) -> Context: ...
+
+
+@t.overload
+def get_current_context(silent: bool = ...) -> Context | None: ...
+
+
+def get_current_context(silent: bool = False) -> Context | None:
+    """Returns the current click context.  This can be used as a way to
+    access the current context object from anywhere.  This is a more implicit
+    alternative to the :func:`pass_context` decorator.  This function is
+    primarily useful for helpers such as :func:`echo` which might be
+    interested in changing its behavior based on the current context.
+
+    To push the current context, :meth:`Context.scope` can be used.
+
+    .. versionadded:: 5.0
+
+    :param silent: if set to `True` the return value is `None` if no context
+                   is available.  The default behavior is to raise a
+                   :exc:`RuntimeError`.
+    """
+    try:
+        return t.cast("Context", _local.stack[-1])
+    except (AttributeError, IndexError) as e:
+        if not silent:
+            raise RuntimeError("There is no active click context.") from e
+
+    return None
+
+
+def push_context(ctx: Context) -> None:
+    """Pushes a new context to the current stack."""
+    _local.__dict__.setdefault("stack", []).append(ctx)
+
+
+def pop_context() -> None:
+    """Removes the top level from the stack."""
+    _local.stack.pop()
+
+
+def resolve_color_default(color: bool | None = None) -> bool | None:
+    """Internal helper to get the default value of the color flag.  If a
+    value is passed it's returned unchanged, otherwise it's looked up from
+    the current context.
+    """
+    if color is not None:
+        return color
+
+    ctx = get_current_context(silent=True)
+
+    if ctx is not None:
+        return ctx.color
+
+    return None

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/click/shell_completion.py

@@ -0,0 +1,680 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import os
+import re
+import typing as t
+from gettext import gettext as _
+
+from .core import Argument
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .core import ParameterSource
+from .utils import echo
+
+
+def shell_complete(
+    cli: Command,
+    ctx_args: cabc.MutableMapping[str, t.Any],
+    prog_name: str,
+    complete_var: str,
+    instruction: str,
+) -> int:
+    """Perform shell completion for the given CLI program.
+
+    :param cli: Command being called.
+    :param ctx_args: Extra arguments to pass to
+        ``cli.make_context``.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+    :param instruction: Value of ``complete_var`` with the completion
+        instruction and shell, in the form ``instruction_shell``.
+    :return: Status code to exit with.
+    """
+    shell, _, instruction = instruction.partition("_")
+    comp_cls = get_completion_class(shell)
+
+    if comp_cls is None:
+        return 1
+
+    comp = comp_cls(cli, ctx_args, prog_name, complete_var)
+
+    # Write bytes, otherwise Windows text stdout translates LF to CRLF and breaks.
+    if instruction == "source":
+        echo(comp.source().encode(), nl=False)
+        return 0
+
+    if instruction == "complete":
+        echo(comp.complete().encode())
+        return 0
+
+    return 1
+
+
+class CompletionItem:
+    """Represents a completion value and metadata about the value. The
+    default metadata is ``type`` to indicate special shell handling,
+    and ``help`` if a shell supports showing a help string next to the
+    value.
+
+    Arbitrary parameters can be passed when creating the object, and
+    accessed using ``item.attr``. If an attribute wasn't passed,
+    accessing it returns ``None``.
+
+    :param value: The completion suggestion.
+    :param type: Tells the shell script to provide special completion
+        support for the type. Click uses ``"dir"`` and ``"file"``.
+    :param help: String shown next to the value if supported.
+    :param kwargs: Arbitrary metadata. The built-in implementations
+        don't use this, but custom type completions paired with custom
+        shell support could use it.
+    """
+
+    __slots__ = ("value", "type", "help", "_info")
+
+    def __init__(
+        self,
+        value: t.Any,
+        type: str = "plain",
+        help: str | None = None,
+        **kwargs: t.Any,
+    ) -> None:
+        self.value: t.Any = value
+        self.type: str = type
+        self.help: str | None = help
+        self._info = kwargs
+
+    def __getattr__(self, name: str) -> t.Any:
+        return self._info.get(name)
+
+
+# Only Bash >= 4.4 has the nosort option.
+_SOURCE_BASH = """\
+%(complete_func)s() {
+    local IFS=$'\\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \
+%(complete_var)s=bash_complete $1)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY=()
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY=()
+            compopt -o default
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+
+    return 0
+}
+
+%(complete_func)s_setup() {
+    complete -o nosort -F %(complete_func)s %(prog_name)s
+}
+
+%(complete_func)s_setup;
+"""
+
+# See ZshComplete.format_completion below, and issue #2703, before
+# changing this script.
+#
+# (TL;DR: _describe is picky about the format, but this Zsh script snippet
+# is already widely deployed.  So freeze this script, and use clever-ish
+# handling of colons in ZshComplet.format_completion.)
+_SOURCE_ZSH = """\
+#compdef %(prog_name)s
+
+%(complete_func)s() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[%(prog_name)s] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \
+%(complete_var)s=zsh_complete %(prog_name)s)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+    # autoload from fpath, call function directly
+    %(complete_func)s "$@"
+else
+    # eval/source/. command, register function for later
+    compdef %(complete_func)s %(prog_name)s
+fi
+"""
+
+_SOURCE_FISH = """\
+function %(complete_func)s;
+    set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
+COMP_CWORD=(commandline -t) %(prog_name)s);
+
+    for completion in $response;
+        set -l metadata (string split \n $completion);
+
+        if test $metadata[1] = "dir";
+            __fish_complete_directories $metadata[2];
+        else if test $metadata[1] = "file";
+            __fish_complete_path $metadata[2];
+        else if test $metadata[1] = "plain";
+            if test $metadata[3] != "_";
+                echo $metadata[2]\t$metadata[3];
+            else;
+                echo $metadata[2];
+            end;
+        end;
+    end;
+end;
+
+complete --no-files --command %(prog_name)s --arguments \
+"(%(complete_func)s)";
+"""
+
+
+class ShellComplete:
+    """Base class for providing shell completion support. A subclass for
+    a given shell will override attributes and methods to implement the
+    completion instructions (``source`` and ``complete``).
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+
+    .. versionadded:: 8.0
+    """
+
+    name: t.ClassVar[str]
+    """Name to register the shell as with :func:`add_completion_class`.
+    This is used in completion instructions (``{name}_source`` and
+    ``{name}_complete``).
+    """
+
+    source_template: t.ClassVar[str]
+    """Completion script template formatted by :meth:`source`. This must
+    be provided by subclasses.
+    """
+
+    def __init__(
+        self,
+        cli: Command,
+        ctx_args: cabc.MutableMapping[str, t.Any],
+        prog_name: str,
+        complete_var: str,
+    ) -> None:
+        self.cli = cli
+        self.ctx_args = ctx_args
+        self.prog_name = prog_name
+        self.complete_var = complete_var
+
+    @property
+    def func_name(self) -> str:
+        """The name of the shell function defined by the completion
+        script.
+        """
+        safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), flags=re.ASCII)
+        return f"_{safe_name}_completion"
+
+    def source_vars(self) -> dict[str, t.Any]:
+        """Vars for formatting :attr:`source_template`.
+
+        By default this provides ``complete_func``, ``complete_var``,
+        and ``prog_name``.
+        """
+        return {
+            "complete_func": self.func_name,
+            "complete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def source(self) -> str:
+        """Produce the shell script that defines the completion
+        function. By default this ``%``-style formats
+        :attr:`source_template` with the dict returned by
+        :meth:`source_vars`.
+        """
+        return self.source_template % self.source_vars()
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        """Use the env vars defined by the shell script to return a
+        tuple of ``args, incomplete``. This must be implemented by
+        subclasses.
+        """
+        raise NotImplementedError
+
+    def get_completions(self, args: list[str], incomplete: str) -> list[CompletionItem]:
+        """Determine the context and last complete command or parameter
+        from the complete args. Call that object's ``shell_complete``
+        method to get the completions for the incomplete value.
+
+        :param args: List of complete args before the incomplete value.
+        :param incomplete: Value being completed. May be empty.
+        """
+        ctx = _resolve_context(self.cli, self.ctx_args, self.prog_name, args)
+        obj, incomplete = _resolve_incomplete(ctx, args, incomplete)
+        return obj.shell_complete(ctx, incomplete)
+
+    def format_completion(self, item: CompletionItem) -> str:
+        """Format a completion item into the form recognized by the
+        shell script. This must be implemented by subclasses.
+
+        :param item: Completion item to format.
+        """
+        raise NotImplementedError
+
+    def complete(self) -> str:
+        """Produce the completion data to send back to the shell.
+
+        By default this calls :meth:`get_completion_args`, gets the
+        completions, then calls :meth:`format_completion` for each
+        completion.
+        """
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        out = [self.format_completion(item) for item in completions]
+        return "\n".join(out)
+
+
+class BashComplete(ShellComplete):
+    """Shell completion for Bash."""
+
+    name = "bash"
+    source_template = _SOURCE_BASH
+
+    @staticmethod
+    def _check_version() -> None:
+        import shutil
+        import subprocess
+
+        bash_exe = shutil.which("bash")
+
+        if bash_exe is None:
+            match = None
+        else:
+            output = subprocess.run(
+                [bash_exe, "--norc", "-c", 'echo "${BASH_VERSION}"'],
+                stdout=subprocess.PIPE,
+            )
+            match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode())
+
+        if match is not None:
+            major, minor = match.groups()
+
+            if major < "4" or major == "4" and minor < "4":
+                echo(
+                    _(
+                        "Shell completion is not supported for Bash"
+                        " versions older than 4.4."
+                    ),
+                    err=True,
+                )
+        else:
+            echo(
+                _("Couldn't detect Bash version, shell completion is not supported."),
+                err=True,
+            )
+
+    def source(self) -> str:
+        self._check_version()
+        return super().source()
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        return f"{item.type},{item.value}"
+
+
+class ZshComplete(ShellComplete):
+    """Shell completion for Zsh."""
+
+    name = "zsh"
+    source_template = _SOURCE_ZSH
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        help_ = item.help or "_"
+        # The zsh completion script uses `_describe` on items with help
+        # texts (which splits the item help from the item value at the
+        # first unescaped colon) and `compadd` on items without help
+        # text (which uses the item value as-is and does not support
+        # colon escaping).  So escape colons in the item value if and
+        # only if the item help is not the sentinel "_" value, as used
+        # by the completion script.
+        #
+        # (The zsh completion script is potentially widely deployed, and
+        # thus harder to fix than this method.)
+        #
+        # See issue #1812 and issue #2703 for further context.
+        value = item.value.replace(":", r"\:") if help_ != "_" else item.value
+        return f"{item.type}\n{value}\n{help_}"
+
+
+class FishComplete(ShellComplete):
+    """Shell completion for Fish."""
+
+    name = "fish"
+    source_template = _SOURCE_FISH
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        incomplete = os.environ["COMP_CWORD"]
+        if incomplete:
+            incomplete = split_arg_string(incomplete)[0]
+        args = cwords[1:]
+
+        # Fish stores the partial word in both COMP_WORDS and
+        # COMP_CWORD, remove it from complete args.
+        if incomplete and args and args[-1] == incomplete:
+            args.pop()
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        """
+        .. versionchanged:: 8.4.0
+            Escape newlines in value and help to fix completion errors with
+            multi-line help strings.
+        """
+        # The fish completion script splits each response line on literal
+        # newlines, so any newline in the value or help would corrupt the
+        # frame. Replace them with the two-character escape "\n" so the text
+        # round-trips through fish without breaking the format. The "_"
+        # sentinel for missing help mirrors :class:`ZshComplete`.
+        help_ = item.help or "_"
+        value = item.value.replace("\n", r"\n")
+        help_escaped = help_.replace("\n", r"\n")
+        return f"{item.type}\n{value}\n{help_escaped}"
+
+
+ShellCompleteType = t.TypeVar("ShellCompleteType", bound="type[ShellComplete]")
+
+
+_available_shells: dict[str, type[ShellComplete]] = {
+    "bash": BashComplete,
+    "fish": FishComplete,
+    "zsh": ZshComplete,
+}
+
+
+def add_completion_class(
+    cls: ShellCompleteType, name: str | None = None
+) -> ShellCompleteType:
+    """Register a :class:`ShellComplete` subclass under the given name.
+    The name will be provided by the completion instruction environment
+    variable during completion.
+
+    :param cls: The completion class that will handle completion for the
+        shell.
+    :param name: Name to register the class under. Defaults to the
+        class's ``name`` attribute.
+    """
+    if name is None:
+        name = cls.name
+
+    _available_shells[name] = cls
+
+    return cls
+
+
+def get_completion_class(shell: str) -> type[ShellComplete] | None:
+    """Look up a registered :class:`ShellComplete` subclass by the name
+    provided by the completion instruction environment variable. If the
+    name isn't registered, returns ``None``.
+
+    :param shell: Name the class is registered under.
+    """
+    return _available_shells.get(shell)
+
+
+def split_arg_string(string: str) -> list[str]:
+    """Split an argument string as with :func:`shlex.split`, but don't
+    fail if the string is incomplete. Ignores a missing closing quote or
+    incomplete escape sequence and uses the partial token as-is.
+
+    .. code-block:: python
+
+        split_arg_string("example 'my file")
+        ["example", "my file"]
+
+        split_arg_string("example my\\")
+        ["example", "my"]
+
+    :param string: String to split.
+
+    .. versionchanged:: 8.2
+        Moved to ``shell_completion`` from ``parser``.
+    """
+    import shlex
+
+    lex = shlex.shlex(string, posix=True)
+    lex.whitespace_split = True
+    lex.commenters = ""
+    out = []
+
+    try:
+        for token in lex:
+            out.append(token)
+    except ValueError:
+        # Raised when end-of-string is reached in an invalid state. Use
+        # the partial token as-is. The quote or escape character is in
+        # lex.state, not lex.token.
+        out.append(lex.token)
+
+    return out
+
+
+def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool:
+    """Determine if the given parameter is an argument that can still
+    accept values.
+
+    :param ctx: Invocation context for the command represented by the
+        parsed complete args.
+    :param param: Argument object being checked.
+    """
+    if not isinstance(param, Argument):
+        return False
+
+    value = ctx.params.get(param.name)
+    return (
+        param.nargs == -1
+        or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE
+        or (
+            param.nargs > 1
+            and isinstance(value, (tuple, list))
+            and len(value) < param.nargs
+        )
+    )
+
+
+def _start_of_option(ctx: Context, value: str) -> bool:
+    """Check if the value looks like the start of an option."""
+    if not value:
+        return False
+
+    c = value[0]
+    return c in ctx._opt_prefixes
+
+
+def _is_incomplete_option(ctx: Context, args: list[str], param: Parameter) -> bool:
+    """Determine if the given parameter is an option that needs a value.
+
+    :param args: List of complete args before the incomplete value.
+    :param param: Option object being checked.
+    """
+    if not isinstance(param, Option):
+        return False
+
+    if param.is_flag or param.count:
+        return False
+
+    last_option = None
+
+    for index, arg in enumerate(reversed(args)):
+        if index + 1 > param.nargs:
+            break
+
+        if _start_of_option(ctx, arg):
+            last_option = arg
+            break
+
+    return last_option is not None and last_option in param.opts
+
+
+def _resolve_context(
+    cli: Command,
+    ctx_args: cabc.MutableMapping[str, t.Any],
+    prog_name: str,
+    args: list[str],
+) -> Context:
+    """Produce the context hierarchy starting with the command and
+    traversing the complete arguments. This only follows the commands,
+    it doesn't trigger input prompts or callbacks.
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param args: List of complete args before the incomplete value.
+    """
+    ctx_args["resilient_parsing"] = True
+    with cli.make_context(prog_name, args.copy(), **ctx_args) as ctx:
+        args = ctx._protected_args + ctx.args
+
+        while args:
+            command = ctx.command
+
+            if isinstance(command, Group):
+                if not command.chain:
+                    name, cmd, args = command.resolve_command(ctx, args)
+
+                    if cmd is None:
+                        return ctx
+
+                    with cmd.make_context(
+                        name, args, parent=ctx, resilient_parsing=True
+                    ) as sub_ctx:
+                        ctx = sub_ctx
+                        args = ctx._protected_args + ctx.args
+                else:
+                    sub_ctx = ctx
+
+                    while args:
+                        name, cmd, args = command.resolve_command(ctx, args)
+
+                        if cmd is None:
+                            return ctx
+
+                        with cmd.make_context(
+                            name,
+                            args,
+                            parent=ctx,
+                            allow_extra_args=True,
+                            allow_interspersed_args=False,
+                            resilient_parsing=True,
+                        ) as sub_sub_ctx:
+                            sub_ctx = sub_sub_ctx
+                            args = sub_ctx.args
+
+                    ctx = sub_ctx
+                    args = [*sub_ctx._protected_args, *sub_ctx.args]
+            else:
+                break
+
+    return ctx
+
+
+def _resolve_incomplete(
+    ctx: Context, args: list[str], incomplete: str
+) -> tuple[Command | Parameter, str]:
+    """Find the Click object that will handle the completion of the
+    incomplete value. Return the object and the incomplete value.
+
+    :param ctx: Invocation context for the command represented by
+        the parsed complete args.
+    :param args: List of complete args before the incomplete value.
+    :param incomplete: Value being completed. May be empty.
+    """
+    # Different shells treat an "=" between a long option name and
+    # value differently. Might keep the value joined, return the "="
+    # as a separate item, or return the split name and value. Always
+    # split and discard the "=" to make completion easier.
+    if incomplete == "=":
+        incomplete = ""
+    elif "=" in incomplete and _start_of_option(ctx, incomplete):
+        name, _, incomplete = incomplete.partition("=")
+        args.append(name)
+
+    # The "--" marker tells Click to stop treating values as options
+    # even if they start with the option character. If it hasn't been
+    # given and the incomplete arg looks like an option, the current
+    # command will provide option name completions.
+    if "--" not in args and _start_of_option(ctx, incomplete):
+        return ctx.command, incomplete
+
+    params = ctx.command.get_params(ctx)
+
+    # If the last complete arg is an option name with an incomplete
+    # value, the option will provide value completions.
+    for param in params:
+        if _is_incomplete_option(ctx, args, param):
+            return param, incomplete
+
+    # It's not an option name or value. The first argument without a
+    # parsed value will provide value completions.
+    for param in params:
+        if _is_incomplete_argument(ctx, param):
+            return param, incomplete
+
+    # There were no unparsed arguments, the command may be a group that
+    # will provide command name completions.
+    return ctx.command, incomplete

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/click/testing.py

@@ -0,0 +1,736 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import contextlib
+import io
+import os
+import pdb
+import shlex
+import sys
+import tempfile
+import typing as t
+from types import TracebackType
+
+from . import _compat
+from . import formatting
+from . import termui
+from . import utils
+from ._compat import _find_binary_reader
+
+if t.TYPE_CHECKING:
+    from _typeshed import ReadableBuffer
+
+    from .core import Command
+
+CaptureMode = t.Literal["sys", "fd"]
+
+
+class EchoingStdin:
+    def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None:
+        self._input = input
+        self._output = output
+        self._paused = False
+
+    def __getattr__(self, x: str) -> t.Any:
+        return getattr(self._input, x)
+
+    def _echo(self, rv: bytes) -> bytes:
+        if not self._paused:
+            self._output.write(rv)
+
+        return rv
+
+    def read(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read(n))
+
+    def read1(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read1(n))  # type: ignore
+
+    def readline(self, n: int = -1) -> bytes:
+        return self._echo(self._input.readline(n))
+
+    def readlines(self) -> list[bytes]:
+        return [self._echo(x) for x in self._input.readlines()]
+
+    def __iter__(self) -> cabc.Iterator[bytes]:
+        return iter(self._echo(x) for x in self._input)
+
+    def __repr__(self) -> str:
+        return repr(self._input)
+
+
+@contextlib.contextmanager
+def _pause_echo(stream: EchoingStdin | None) -> cabc.Iterator[None]:
+    if stream is None:
+        yield
+    else:
+        stream._paused = True
+        yield
+        stream._paused = False
+
+
+class _FDCapture:
+    """Redirect a file descriptor to a temporary file for capture.
+
+    Saves the current target of *targetfd* via :func:`os.dup`, then
+    redirects it to a temporary file via :func:`os.dup2`. On
+    :meth:`stop`, restores the original ``fd`` and returns the captured
+    bytes. Inspired by Pytest's ``FDCapture``.
+
+    .. versionadded:: 8.4.0
+    """
+
+    def __init__(self, targetfd: int) -> None:
+        self._targetfd = targetfd
+        self.saved_fd: int = -1
+        self._tmpfile: t.BinaryIO | None = None
+
+    def start(self) -> None:
+        self.saved_fd = os.dup(self._targetfd)
+        self._tmpfile = tempfile.TemporaryFile(buffering=0)
+        os.dup2(self._tmpfile.fileno(), self._targetfd)
+
+    def stop(self) -> bytes:
+        assert self._tmpfile is not None, "_FDCapture.start() was not called"
+        os.dup2(self.saved_fd, self._targetfd)
+        os.close(self.saved_fd)
+        self.saved_fd = -1
+        self._tmpfile.seek(0)
+        data = self._tmpfile.read()
+        self._tmpfile.close()
+        self._tmpfile = None
+        return data
+
+
+class BytesIOCopy(io.BytesIO):
+    """Patch ``io.BytesIO`` to let the written stream be copied to another.
+
+    .. versionadded:: 8.2
+    """
+
+    def __init__(self, copy_to: io.BytesIO) -> None:
+        super().__init__()
+        self.copy_to = copy_to
+
+    def flush(self) -> None:
+        super().flush()
+        self.copy_to.flush()
+
+    def write(self, b: ReadableBuffer) -> int:
+        self.copy_to.write(b)
+        return super().write(b)
+
+
+class StreamMixer:
+    """Mixes `<stdout>` and `<stderr>` streams.
+
+    The result is available in the ``output`` attribute.
+
+    .. versionadded:: 8.2
+    """
+
+    def __init__(self) -> None:
+        self.output: io.BytesIO = io.BytesIO()
+        self.stdout: io.BytesIO = BytesIOCopy(copy_to=self.output)
+        self.stderr: io.BytesIO = BytesIOCopy(copy_to=self.output)
+
+
+class _NamedTextIOWrapper(io.TextIOWrapper):
+    """A :class:`~io.TextIOWrapper` with custom ``name`` and ``mode``
+    that does not close its underlying buffer.
+
+    When ``CliRunner`` runs in ``fd`` mode, ``_original_fd`` is patched to
+    point at the saved (pre-redirection) ``fd``, so C-level consumers that call
+    :meth:`fileno` (like ``faulthandler`` or ``subprocess``) keep working. In
+    the default ``sys`` mode ``_original_fd`` stays at ``-1`` and
+    :meth:`fileno` raises :exc:`io.UnsupportedOperation`, matching the
+    pre-``8.3.3`` behavior.
+    """
+
+    def __init__(
+        self,
+        buffer: t.BinaryIO,
+        name: str,
+        mode: str,
+        **kwargs: t.Any,
+    ) -> None:
+        super().__init__(buffer, **kwargs)
+        self._name = name
+        self._mode = mode
+        self._original_fd: int = -1
+
+    def close(self) -> None:
+        """The buffer this object contains belongs to some other object,
+        so prevent the default ``__del__`` implementation from closing
+        that buffer.
+
+        .. versionadded:: 8.3.2
+        """
+
+    def fileno(self) -> int:
+        """Return the file descriptor of the saved original stream when
+        ``CliRunner`` runs in ``fd`` mode. Otherwise delegate to
+        :class:`~io.TextIOWrapper`, which raises
+        :exc:`io.UnsupportedOperation` for a ``BytesIO``-backed buffer.
+        """
+        if self._original_fd >= 0:
+            return self._original_fd
+        return super().fileno()
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+
+def make_input_stream(
+    input: str | bytes | t.IO[t.Any] | None, charset: str
+) -> t.BinaryIO:
+    # Is already an input stream.
+    if hasattr(input, "read"):
+        rv = _find_binary_reader(t.cast("t.IO[t.Any]", input))
+
+        if rv is not None:
+            return rv
+
+        raise TypeError("Could not find binary reader for input stream.")
+
+    if input is None:
+        input = b""
+    elif isinstance(input, str):
+        input = input.encode(charset)
+
+    return io.BytesIO(input)
+
+
+class Result:
+    """Holds the captured result of an invoked CLI script.
+
+    :param runner: The runner that created the result
+    :param stdout_bytes: The standard output as bytes.
+    :param stderr_bytes: The standard error as bytes.
+    :param output_bytes: A mix of ``stdout_bytes`` and ``stderr_bytes``, as the
+        user would see  it in its terminal.
+    :param return_value: The value returned from the invoked command.
+    :param exit_code: The exit code as integer.
+    :param exception: The exception that happened if one did.
+    :param exc_info: Exception information (exception type, exception instance,
+        traceback type).
+
+    .. versionchanged:: 8.2
+        ``stderr_bytes`` no longer optional, ``output_bytes`` introduced and
+        ``mix_stderr`` has been removed.
+
+    .. versionadded:: 8.0
+        Added ``return_value``.
+    """
+
+    def __init__(
+        self,
+        runner: CliRunner,
+        stdout_bytes: bytes,
+        stderr_bytes: bytes,
+        output_bytes: bytes,
+        return_value: t.Any,
+        exit_code: int,
+        exception: BaseException | None,
+        exc_info: tuple[type[BaseException], BaseException, TracebackType]
+        | None = None,
+    ):
+        self.runner = runner
+        self.stdout_bytes = stdout_bytes
+        self.stderr_bytes = stderr_bytes
+        self.output_bytes = output_bytes
+        self.return_value = return_value
+        self.exit_code = exit_code
+        self.exception = exception
+        self.exc_info = exc_info
+
+    @property
+    def output(self) -> str:
+        """The terminal output as unicode string, as the user would see it.
+
+        .. versionchanged:: 8.2
+            No longer a proxy for ``self.stdout``. Now has its own independent stream
+            that is mixing `<stdout>` and `<stderr>`, in the order they were written.
+        """
+        return self.output_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    @property
+    def stdout(self) -> str:
+        """The standard output as unicode string."""
+        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    @property
+    def stderr(self) -> str:
+        """The standard error as unicode string.
+
+        .. versionchanged:: 8.2
+            No longer raise an exception, always returns the `<stderr>` string.
+        """
+        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    def __repr__(self) -> str:
+        exc_str = repr(self.exception) if self.exception else "okay"
+        return f"<{type(self).__name__} {exc_str}>"
+
+
+class CliRunner:
+    """The CLI runner provides functionality to invoke a Click command line
+    script for unittesting purposes in a isolated environment.  This only
+    works in single-threaded systems without any concurrency as it changes the
+    global interpreter state.
+
+    :param charset: the character set for the input and output data.
+    :param env: a dictionary with environment variables for overriding.
+    :param echo_stdin: if this is set to `True`, then reading from `<stdin>` writes
+                       to `<stdout>`.  This is useful for showing examples in
+                       some circumstances.  Note that regular prompts
+                       will automatically echo the input.
+    :param catch_exceptions: Whether to catch any exceptions other than
+                             ``SystemExit`` when running :meth:`~CliRunner.invoke`.
+    :param capture: Selects the output capture strategy. ``sys`` (default)
+        captures Python-level writes only and leaves
+        :meth:`sys.stdout.fileno` raising :exc:`io.UnsupportedOperation`, so
+        user code that calls :func:`os.dup2` on ``sys.stdout.fileno()`` cannot
+        clobber the host runner's stdout. ``fd`` redirects file descriptors
+        ``1`` and ``2`` via :func:`os.dup2` to a temporary file, also catching
+        output from stale stream references, C extensions, and subprocesses.
+        ``fd`` is not supported on Windows.
+
+    .. versionchanged:: 8.4.0
+        Added the ``capture`` parameter. The default ``sys`` mode no longer
+        exposes the original fd through :meth:`fileno`, reverting the change
+        introduced in ``8.3.3`` that broke Pytest's ``fd``-level capture
+        teardown. Use ``capture="fd"`` to restore that behavior with proper
+        isolation. :issue:`3384`
+
+    .. versionchanged:: 8.2
+        Added the ``catch_exceptions`` parameter.
+
+    .. versionchanged:: 8.2
+        ``mix_stderr`` parameter has been removed.
+    """
+
+    def __init__(
+        self,
+        charset: str = "utf-8",
+        env: cabc.Mapping[str, str | None] | None = None,
+        echo_stdin: bool = False,
+        catch_exceptions: bool = True,
+        capture: CaptureMode = "sys",
+    ) -> None:
+        if capture not in {"sys", "fd"}:
+            raise ValueError(
+                f"capture={capture!r} is not valid. Choose from 'sys' or 'fd'."
+            )
+        if capture == "fd" and sys.platform == "win32":
+            raise ValueError(
+                f"capture={capture!r} is not supported on Windows. Use 'sys'."
+            )
+        self.charset = charset
+        self.env: cabc.Mapping[str, str | None] = env or {}
+        self.echo_stdin = echo_stdin
+        self.catch_exceptions = catch_exceptions
+        self.capture: CaptureMode = capture
+
+    def get_default_prog_name(self, cli: Command) -> str:
+        """Given a command object it will return the default program name
+        for it.  The default is the `name` attribute or ``"root"`` if not
+        set.
+        """
+        return cli.name or "root"
+
+    def make_env(
+        self, overrides: cabc.Mapping[str, str | None] | None = None
+    ) -> cabc.Mapping[str, str | None]:
+        """Returns the environment overrides for invoking a script."""
+        rv = dict(self.env)
+        if overrides:
+            rv.update(overrides)
+        return rv
+
+    @contextlib.contextmanager
+    def isolation(
+        self,
+        input: str | bytes | t.IO[t.Any] | None = None,
+        env: cabc.Mapping[str, str | None] | None = None,
+        color: bool = False,
+    ) -> cabc.Iterator[tuple[io.BytesIO, io.BytesIO, io.BytesIO]]:
+        """A context manager that sets up the isolation for invoking of a
+        command line tool.  This sets up `<stdin>` with the given input data
+        and `os.environ` with the overrides from the given dictionary.
+        This also rebinds some internals in Click to be mocked (like the
+        prompt functionality).
+
+        This is automatically done in the :meth:`invoke` method.
+
+        :param input: the input stream to put into `sys.stdin`.
+        :param env: the environment overrides as dictionary.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionadded:: 8.2
+            An additional output stream is returned, which is a mix of
+            `<stdout>` and `<stderr>` streams.
+
+        .. versionchanged:: 8.2
+            Always returns the `<stderr>` stream.
+
+        .. versionchanged:: 8.0
+            `<stderr>` is opened with ``errors="backslashreplace"``
+            instead of the default ``"strict"``.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+        """
+        bytes_input = make_input_stream(input, self.charset)
+        echo_input = None
+
+        old_stdin = sys.stdin
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        old_forced_width = formatting.FORCED_WIDTH
+        formatting.FORCED_WIDTH = 80
+
+        env = self.make_env(env)
+
+        stream_mixer = StreamMixer()
+
+        if self.echo_stdin:
+            bytes_input = echo_input = t.cast(
+                t.BinaryIO, EchoingStdin(bytes_input, stream_mixer.stdout)
+            )
+
+        sys.stdin = text_input = _NamedTextIOWrapper(
+            bytes_input, encoding=self.charset, name="<stdin>", mode="r"
+        )
+
+        if self.echo_stdin:
+            # Force unbuffered reads, otherwise TextIOWrapper reads a
+            # large chunk which is echoed early.
+            text_input._CHUNK_SIZE = 1  # type: ignore
+
+        sys.stdout = _NamedTextIOWrapper(
+            stream_mixer.stdout,
+            encoding=self.charset,
+            name="<stdout>",
+            mode="w",
+        )
+
+        sys.stderr = _NamedTextIOWrapper(
+            stream_mixer.stderr,
+            encoding=self.charset,
+            name="<stderr>",
+            mode="w",
+            errors="backslashreplace",
+        )
+
+        @_pause_echo(echo_input)  # type: ignore
+        def visible_input(prompt: str | None = None) -> str:
+            sys.stdout.write(prompt or "")
+            try:
+                val = next(text_input).rstrip("\r\n")
+            except StopIteration as e:
+                raise EOFError() from e
+            sys.stdout.write(f"{val}\n")
+            sys.stdout.flush()
+            return val
+
+        @_pause_echo(echo_input)  # type: ignore
+        def hidden_input(prompt: str | None = None) -> str:
+            sys.stdout.write(f"{prompt or ''}\n")
+            sys.stdout.flush()
+            try:
+                return next(text_input).rstrip("\r\n")
+            except StopIteration as e:
+                raise EOFError() from e
+
+        @_pause_echo(echo_input)  # type: ignore
+        def _getchar(echo: bool) -> str:
+            char = sys.stdin.read(1)
+
+            if echo:
+                sys.stdout.write(char)
+
+            sys.stdout.flush()
+            return char
+
+        default_color = color
+
+        def should_strip_ansi(
+            stream: t.IO[t.Any] | None = None, color: bool | None = None
+        ) -> bool:
+            if color is None:
+                return not default_color
+            return not color
+
+        old_visible_prompt_func = termui.visible_prompt_func
+        old_hidden_prompt_func = termui.hidden_prompt_func
+        old__getchar_func = termui._getchar
+        old_should_strip_ansi = utils.should_strip_ansi  # type: ignore
+        old__compat_should_strip_ansi = _compat.should_strip_ansi
+        old_pdb_init = pdb.Pdb.__init__
+        termui.visible_prompt_func = visible_input
+        termui.hidden_prompt_func = hidden_input
+        termui._getchar = _getchar
+        utils.should_strip_ansi = should_strip_ansi  # type: ignore
+        _compat.should_strip_ansi = should_strip_ansi
+
+        def _patched_pdb_init(
+            self: pdb.Pdb,
+            completekey: str = "tab",
+            stdin: t.IO[str] | None = None,
+            stdout: t.IO[str] | None = None,
+            **kwargs: t.Any,
+        ) -> None:
+            """Default ``pdb.Pdb`` to real terminal streams during
+            ``CliRunner`` isolation.
+
+            Without this patch, ``pdb.Pdb.__init__`` inherits from
+            ``cmd.Cmd`` which falls back to ``sys.stdin``/``sys.stdout``
+            when no explicit streams are provided. During isolation
+            those are ``BytesIO``-backed wrappers, so the debugger
+            reads from an empty buffer and writes to captured output,
+            making interactive debugging impossible.
+
+            By defaulting to ``sys.__stdin__``/``sys.__stdout__`` (the
+            original terminal streams Python preserves regardless of
+            redirection), debuggers can interact with the user while
+            ``click.echo`` output is still captured normally.
+
+            This covers ``pdb.set_trace()``, ``breakpoint()``,
+            ``pdb.post_mortem()``, and debuggers that subclass
+            ``pdb.Pdb`` (ipdb, pdbpp). Explicit ``stdin``/``stdout``
+            arguments are honored and not overridden. Debuggers that
+            do not subclass ``pdb.Pdb`` (pudb, debugpy) are not
+            covered.
+            """
+            if stdin is None:
+                stdin = sys.__stdin__
+            if stdout is None:
+                stdout = sys.__stdout__
+            old_pdb_init(
+                self, completekey=completekey, stdin=stdin, stdout=stdout, **kwargs
+            )
+
+        pdb.Pdb.__init__ = _patched_pdb_init  # type: ignore[assignment]
+
+        old_env = {}
+        try:
+            for key, value in env.items():
+                old_env[key] = os.environ.get(key)
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            yield (stream_mixer.stdout, stream_mixer.stderr, stream_mixer.output)
+        finally:
+            for key, value in old_env.items():
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            sys.stdin = old_stdin
+            termui.visible_prompt_func = old_visible_prompt_func
+            termui.hidden_prompt_func = old_hidden_prompt_func
+            termui._getchar = old__getchar_func
+            utils.should_strip_ansi = old_should_strip_ansi  # type: ignore
+            _compat.should_strip_ansi = old__compat_should_strip_ansi
+            formatting.FORCED_WIDTH = old_forced_width
+            pdb.Pdb.__init__ = old_pdb_init  # type: ignore[method-assign]
+
+    def invoke(
+        self,
+        cli: Command,
+        args: str | cabc.Sequence[str] | None = None,
+        input: str | bytes | t.IO[t.Any] | None = None,
+        env: cabc.Mapping[str, str | None] | None = None,
+        catch_exceptions: bool | None = None,
+        color: bool = False,
+        **extra: t.Any,
+    ) -> Result:
+        """Invokes a command in an isolated environment.  The arguments are
+        forwarded directly to the command line script, the `extra` keyword
+        arguments are passed to the :meth:`~clickpkg.Command.main` function of
+        the command.
+
+        This returns a :class:`Result` object.
+
+        :param cli: the command to invoke
+        :param args: the arguments to invoke. It may be given as an iterable
+                     or a string. When given as string it will be interpreted
+                     as a Unix shell command. More details at
+                     :func:`shlex.split`.
+        :param input: the input data for `sys.stdin`.
+        :param env: the environment overrides.
+        :param catch_exceptions: Whether to catch any other exceptions than
+                                 ``SystemExit``. If :data:`None`, the value
+                                 from :class:`CliRunner` is used.
+        :param extra: the keyword arguments to pass to :meth:`main`.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionadded:: 8.2
+            The result object has the ``output_bytes`` attribute with
+            the mix of ``stdout_bytes`` and ``stderr_bytes``, as the user would
+            see it in its terminal.
+
+        .. versionchanged:: 8.2
+            The result object always returns the ``stderr_bytes`` stream.
+
+        .. versionchanged:: 8.0
+            The result object has the ``return_value`` attribute with
+            the value returned from the invoked command.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+
+        .. versionchanged:: 3.0
+            Added the ``catch_exceptions`` parameter.
+
+        .. versionchanged:: 3.0
+            The result object has the ``exc_info`` attribute with the
+            traceback if available.
+        """
+        exc_info = None
+        if catch_exceptions is None:
+            catch_exceptions = self.catch_exceptions
+
+        # Set up fd capture before isolation replaces sys.stdout and sys.stderr.
+        cap_out: _FDCapture | None = None
+        cap_err: _FDCapture | None = None
+
+        if self.capture == "fd":
+            cap_out = _FDCapture(1)
+            cap_err = _FDCapture(2)
+            try:
+                cap_out.start()
+                cap_err.start()
+            except OSError:
+                cap_out = cap_err = None
+
+        with self.isolation(input=input, env=env, color=color) as outstreams:
+            # Point the captured streams' fileno() at the saved (original)
+            # fd so that C-level consumers like faulthandler keep working
+            # while fd 1/2 are redirected to the capture tmpfile.
+            if cap_out is not None and cap_err is not None:
+                sys.stdout._original_fd = cap_out.saved_fd  # type: ignore[union-attr]
+                sys.stderr._original_fd = cap_err.saved_fd  # type: ignore[union-attr]
+
+            return_value = None
+            exception: BaseException | None = None
+            exit_code = 0
+
+            if isinstance(args, str):
+                args = shlex.split(args)
+
+            try:
+                prog_name = extra.pop("prog_name")
+            except KeyError:
+                prog_name = self.get_default_prog_name(cli)
+
+            try:
+                return_value = cli.main(args=args or (), prog_name=prog_name, **extra)
+            except SystemExit as e:
+                exc_info = sys.exc_info()
+                e_code = t.cast("int | t.Any | None", e.code)
+
+                if e_code is None:
+                    e_code = 0
+
+                if e_code != 0:
+                    exception = e
+
+                if not isinstance(e_code, int):
+                    sys.stdout.write(str(e_code))
+                    sys.stdout.write("\n")
+                    e_code = 1
+
+                exit_code = e_code
+
+            except Exception as e:
+                if not catch_exceptions:
+                    raise
+                exception = e
+                exit_code = 1
+                exc_info = sys.exc_info()
+            finally:
+                sys.stdout.flush()
+                sys.stderr.flush()
+
+                # Stop fd capture and merge the captured bytes into
+                # the stdout/stderr BytesIO streams. BytesIOCopy mirrors
+                # those writes into outstreams[2] automatically.
+                if cap_out is not None and cap_err is not None:
+                    fd_out = cap_out.stop()
+                    fd_err = cap_err.stop()
+                    if fd_out:
+                        outstreams[0].write(fd_out)
+                    if fd_err:
+                        outstreams[1].write(fd_err)
+
+                stdout = outstreams[0].getvalue()
+                stderr = outstreams[1].getvalue()
+                output = outstreams[2].getvalue()
+
+        return Result(
+            runner=self,
+            stdout_bytes=stdout,
+            stderr_bytes=stderr,
+            output_bytes=output,
+            return_value=return_value,
+            exit_code=exit_code,
+            exception=exception,
+            exc_info=exc_info,  # type: ignore
+        )
+
+    @contextlib.contextmanager
+    def isolated_filesystem(
+        self, temp_dir: str | os.PathLike[str] | None = None
+    ) -> cabc.Iterator[str]:
+        """A context manager that creates a temporary directory and
+        changes the current working directory to it. This isolates tests
+        that affect the contents of the CWD to prevent them from
+        interfering with each other.
+
+        :param temp_dir: Create the temporary directory under this
+            directory. If given, the created directory is not removed
+            when exiting.
+
+        .. versionchanged:: 8.0
+            Added the ``temp_dir`` parameter.
+        """
+        cwd = os.getcwd()
+        dt = tempfile.mkdtemp(dir=temp_dir)
+        os.chdir(dt)
+
+        try:
+            yield dt
+        finally:
+            os.chdir(cwd)
+
+            if temp_dir is None:
+                import shutil
+
+                try:
+                    shutil.rmtree(dt)
+                except OSError:
+                    pass

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/packaging/licenses/__init__.py

@@ -0,0 +1,186 @@
+#######################################################################################
+#
+# Adapted from:
+#  https://github.com/pypa/hatch/blob/5352e44/backend/src/hatchling/licenses/parse.py
+#
+# MIT License
+#
+# Copyright (c) 2017-present Ofek Lev <oss@ofek.dev>
+#
+# 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.
+#
+#
+# With additional allowance of arbitrary `LicenseRef-` identifiers, not just
+# `LicenseRef-Public-Domain` and `LicenseRef-Proprietary`.
+#
+#######################################################################################
+from __future__ import annotations
+
+import re
+from typing import NewType, cast
+
+from ._spdx import EXCEPTIONS, LICENSES
+
+__all__ = [
+    "InvalidLicenseExpression",
+    "NormalizedLicenseExpression",
+    "canonicalize_license_expression",
+]
+
+
+# Simple __dir__ implementation since there are no public submodules
+def __dir__() -> list[str]:
+    return __all__
+
+
+license_ref_allowed = re.compile("^[A-Za-z0-9.-]*$")
+
+NormalizedLicenseExpression = NewType("NormalizedLicenseExpression", str)
+"""
+A :class:`typing.NewType` of :class:`str`, representing a normalized
+License-Expression.
+"""
+
+
+class InvalidLicenseExpression(ValueError):
+    """Raised when a license-expression string is invalid
+
+    >>> from packaging.licenses import canonicalize_license_expression
+    >>> canonicalize_license_expression("invalid")
+    Traceback (most recent call last):
+        ...
+    packaging.licenses.InvalidLicenseExpression: Invalid license expression: 'invalid'
+    """
+
+
+def canonicalize_license_expression(
+    raw_license_expression: str,
+) -> NormalizedLicenseExpression:
+    """
+    This function takes a valid License-Expression, and returns the normalized
+    form of it.
+
+    The return type is typed as :class:`NormalizedLicenseExpression`. This
+    allows type checkers to help require that a string has passed through this
+    function before use.
+
+    :param str raw_license_expression: The License-Expression to canonicalize.
+    :raises InvalidLicenseExpression: If the License-Expression is invalid due to an
+        invalid/unknown license identifier or invalid syntax.
+
+    .. doctest::
+
+        >>> from packaging.licenses import canonicalize_license_expression
+        >>> canonicalize_license_expression("mit")
+        'MIT'
+        >>> canonicalize_license_expression("mit and (apache-2.0 or bsd-2-clause)")
+        'MIT AND (Apache-2.0 OR BSD-2-Clause)'
+        >>> canonicalize_license_expression("(mit")
+        Traceback (most recent call last):
+          ...
+        InvalidLicenseExpression: Invalid license expression: '(mit'
+        >>> canonicalize_license_expression("Use-it-after-midnight")
+        Traceback (most recent call last):
+          ...
+        InvalidLicenseExpression: Unknown license: 'Use-it-after-midnight'
+    """
+    if not raw_license_expression:
+        message = f"Invalid license expression: {raw_license_expression!r}"
+        raise InvalidLicenseExpression(message)
+
+    # Pad any parentheses so tokenization can be achieved by merely splitting on
+    # whitespace.
+    license_expression = raw_license_expression.replace("(", " ( ").replace(")", " ) ")
+    licenseref_prefix = "LicenseRef-"
+    license_refs = {
+        ref.lower(): "LicenseRef-" + ref[len(licenseref_prefix) :]
+        for ref in license_expression.split()
+        if ref.lower().startswith(licenseref_prefix.lower())
+    }
+
+    # Normalize to lower case so we can look up licenses/exceptions
+    # and so boolean operators are Python-compatible.
+    license_expression = license_expression.lower()
+
+    tokens = license_expression.split()
+
+    # Rather than implementing a parenthesis/boolean logic parser, create an
+    # expression that Python can parse. Everything that is not involved with the
+    # grammar itself is replaced with the placeholder `False` and the resultant
+    # expression should become a valid Python expression.
+    python_tokens = []
+    for token in tokens:
+        if token not in {"or", "and", "with", "(", ")"}:
+            python_tokens.append("False")
+        elif token == "with":
+            python_tokens.append("or")
+        elif (
+            token == "("
+            and python_tokens
+            and python_tokens[-1] not in {"or", "and", "("}
+        ) or (token == ")" and python_tokens and python_tokens[-1] == "("):
+            message = f"Invalid license expression: {raw_license_expression!r}"
+            raise InvalidLicenseExpression(message)
+        else:
+            python_tokens.append(token)
+
+    python_expression = " ".join(python_tokens)
+    try:
+        compile(python_expression, "", "eval")
+    except SyntaxError:
+        message = f"Invalid license expression: {raw_license_expression!r}"
+        raise InvalidLicenseExpression(message) from None
+
+    # Take a final pass to check for unknown licenses/exceptions.
+    normalized_tokens = []
+    for token in tokens:
+        if token in {"or", "and", "with", "(", ")"}:
+            normalized_tokens.append(token.upper())
+            continue
+
+        if normalized_tokens and normalized_tokens[-1] == "WITH":
+            if token not in EXCEPTIONS:
+                message = f"Unknown license exception: {token!r}"
+                raise InvalidLicenseExpression(message)
+
+            normalized_tokens.append(EXCEPTIONS[token]["id"])
+        else:
+            if token.endswith("+"):
+                final_token = token[:-1]
+                suffix = "+"
+            else:
+                final_token = token
+                suffix = ""
+
+            if final_token.startswith("licenseref-"):
+                if not license_ref_allowed.match(final_token):
+                    message = f"Invalid licenseref: {final_token!r}"
+                    raise InvalidLicenseExpression(message)
+                normalized_tokens.append(license_refs[final_token] + suffix)
+            else:
+                if final_token not in LICENSES:
+                    message = f"Unknown license: {final_token!r}"
+                    raise InvalidLicenseExpression(message)
+                normalized_tokens.append(LICENSES[final_token]["id"] + suffix)
+
+    normalized_expression = " ".join(normalized_tokens)
+
+    return cast(
+        "NormalizedLicenseExpression",
+        normalized_expression.replace("( ", "(").replace(" )", ")"),
+    )

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/_mapping.py

@@ -0,0 +1,54 @@
+# Automatically generated by scripts/gen_mapfiles.py.
+# DO NOT EDIT BY HAND; run `tox -e mapfiles` instead.
+
+STYLES = {
+    'AbapStyle': ('pygments.styles.abap', 'abap', ()),
+    'AlgolStyle': ('pygments.styles.algol', 'algol', ()),
+    'Algol_NuStyle': ('pygments.styles.algol_nu', 'algol_nu', ()),
+    'ArduinoStyle': ('pygments.styles.arduino', 'arduino', ()),
+    'AutumnStyle': ('pygments.styles.autumn', 'autumn', ()),
+    'BlackWhiteStyle': ('pygments.styles.bw', 'bw', ()),
+    'BorlandStyle': ('pygments.styles.borland', 'borland', ()),
+    'CoffeeStyle': ('pygments.styles.coffee', 'coffee', ()),
+    'ColorfulStyle': ('pygments.styles.colorful', 'colorful', ()),
+    'DefaultStyle': ('pygments.styles.default', 'default', ()),
+    'DraculaStyle': ('pygments.styles.dracula', 'dracula', ()),
+    'EmacsStyle': ('pygments.styles.emacs', 'emacs', ()),
+    'FriendlyGrayscaleStyle': ('pygments.styles.friendly_grayscale', 'friendly_grayscale', ()),
+    'FriendlyStyle': ('pygments.styles.friendly', 'friendly', ()),
+    'FruityStyle': ('pygments.styles.fruity', 'fruity', ()),
+    'GhDarkStyle': ('pygments.styles.gh_dark', 'github-dark', ()),
+    'GruvboxDarkStyle': ('pygments.styles.gruvbox', 'gruvbox-dark', ()),
+    'GruvboxLightStyle': ('pygments.styles.gruvbox', 'gruvbox-light', ()),
+    'IgorStyle': ('pygments.styles.igor', 'igor', ()),
+    'InkPotStyle': ('pygments.styles.inkpot', 'inkpot', ()),
+    'LightbulbStyle': ('pygments.styles.lightbulb', 'lightbulb', ()),
+    'LilyPondStyle': ('pygments.styles.lilypond', 'lilypond', ()),
+    'LovelaceStyle': ('pygments.styles.lovelace', 'lovelace', ()),
+    'ManniStyle': ('pygments.styles.manni', 'manni', ()),
+    'MaterialStyle': ('pygments.styles.material', 'material', ()),
+    'MonokaiStyle': ('pygments.styles.monokai', 'monokai', ()),
+    'MurphyStyle': ('pygments.styles.murphy', 'murphy', ()),
+    'NativeStyle': ('pygments.styles.native', 'native', ()),
+    'NordDarkerStyle': ('pygments.styles.nord', 'nord-darker', ()),
+    'NordStyle': ('pygments.styles.nord', 'nord', ()),
+    'OneDarkStyle': ('pygments.styles.onedark', 'one-dark', ()),
+    'ParaisoDarkStyle': ('pygments.styles.paraiso_dark', 'paraiso-dark', ()),
+    'ParaisoLightStyle': ('pygments.styles.paraiso_light', 'paraiso-light', ()),
+    'PastieStyle': ('pygments.styles.pastie', 'pastie', ()),
+    'PerldocStyle': ('pygments.styles.perldoc', 'perldoc', ()),
+    'RainbowDashStyle': ('pygments.styles.rainbow_dash', 'rainbow_dash', ()),
+    'RrtStyle': ('pygments.styles.rrt', 'rrt', ()),
+    'SasStyle': ('pygments.styles.sas', 'sas', ()),
+    'SolarizedDarkStyle': ('pygments.styles.solarized', 'solarized-dark', ()),
+    'SolarizedLightStyle': ('pygments.styles.solarized', 'solarized-light', ()),
+    'StarofficeStyle': ('pygments.styles.staroffice', 'staroffice', ()),
+    'StataDarkStyle': ('pygments.styles.stata_dark', 'stata-dark', ()),
+    'StataLightStyle': ('pygments.styles.stata_light', 'stata-light', ()),
+    'TangoStyle': ('pygments.styles.tango', 'tango', ()),
+    'TracStyle': ('pygments.styles.trac', 'trac', ()),
+    'VimStyle': ('pygments.styles.vim', 'vim', ()),
+    'VisualStudioStyle': ('pygments.styles.vs', 'vs', ()),
+    'XcodeStyle': ('pygments.styles.xcode', 'xcode', ()),
+    'ZenburnStyle': ('pygments.styles.zenburn', 'zenburn', ()),
+}

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/arduino.py

@@ -0,0 +1,100 @@
+"""
+    pygments.styles.arduino
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Arduino® Syntax highlighting style.
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+    Number, Operator, Generic, Whitespace
+
+
+__all__ = ['ArduinoStyle']
+
+
+class ArduinoStyle(Style):
+    """
+    The Arduino® language style. This style is designed to highlight the
+    Arduino source code, so expect the best results with it.
+    """
+    name = 'arduino'
+
+    background_color = "#ffffff"
+
+    styles = {
+        Whitespace:                "",         # class: 'w'
+        Error:                     "#a61717",  # class: 'err'
+
+        Comment:                   "#95a5a6",  # class: 'c'
+        Comment.Multiline:         "",         # class: 'cm'
+        Comment.Preproc:           "#728E00",  # class: 'cp'
+        Comment.Single:            "",         # class: 'c1'
+        Comment.Special:           "",         # class: 'cs'
+
+        Keyword:                   "#728E00",  # class: 'k'
+        Keyword.Constant:          "#00979D",  # class: 'kc'
+        Keyword.Declaration:       "",         # class: 'kd'
+        Keyword.Namespace:         "",         # class: 'kn'
+        Keyword.Pseudo:            "#00979D",  # class: 'kp'
+        Keyword.Reserved:          "#00979D",  # class: 'kr'
+        Keyword.Type:              "#00979D",  # class: 'kt'
+
+        Operator:                  "#728E00",  # class: 'o'
+        Operator.Word:             "",         # class: 'ow'
+
+        Name:                      "#434f54",  # class: 'n'
+        Name.Attribute:            "",         # class: 'na'
+        Name.Builtin:              "#728E00",  # class: 'nb'
+        Name.Builtin.Pseudo:       "",         # class: 'bp'
+        Name.Class:                "",         # class: 'nc'
+        Name.Constant:             "",         # class: 'no'
+        Name.Decorator:            "",         # class: 'nd'
+        Name.Entity:               "",         # class: 'ni'
+        Name.Exception:            "",         # class: 'ne'
+        Name.Function:             "#D35400",  # class: 'nf'
+        Name.Property:             "",         # class: 'py'
+        Name.Label:                "",         # class: 'nl'
+        Name.Namespace:            "",         # class: 'nn'
+        Name.Other:                "#728E00",  # class: 'nx'
+        Name.Tag:                  "",         # class: 'nt'
+        Name.Variable:             "",         # class: 'nv'
+        Name.Variable.Class:       "",         # class: 'vc'
+        Name.Variable.Global:      "",         # class: 'vg'
+        Name.Variable.Instance:    "",         # class: 'vi'
+
+        Number:                    "#8A7B52",  # class: 'm'
+        Number.Float:              "",         # class: 'mf'
+        Number.Hex:                "",         # class: 'mh'
+        Number.Integer:            "",         # class: 'mi'
+        Number.Integer.Long:       "",         # class: 'il'
+        Number.Oct:                "",         # class: 'mo'
+
+        String:                    "#7F8C8D",  # class: 's'
+        String.Backtick:           "",         # class: 'sb'
+        String.Char:               "",         # class: 'sc'
+        String.Doc:                "",         # class: 'sd'
+        String.Double:             "",         # class: 's2'
+        String.Escape:             "",         # class: 'se'
+        String.Heredoc:            "",         # class: 'sh'
+        String.Interpol:           "",         # class: 'si'
+        String.Other:              "",         # class: 'sx'
+        String.Regex:              "",         # class: 'sr'
+        String.Single:             "",         # class: 's1'
+        String.Symbol:             "",         # class: 'ss'
+
+        Generic:                   "",         # class: 'g'
+        Generic.Deleted:           "",         # class: 'gd',
+        Generic.Emph:              "",         # class: 'ge'
+        Generic.Error:             "",         # class: 'gr'
+        Generic.Heading:           "",         # class: 'gh'
+        Generic.Inserted:          "",         # class: 'gi'
+        Generic.Output:            "",         # class: 'go'
+        Generic.Prompt:            "",         # class: 'gp'
+        Generic.Strong:            "",         # class: 'gs'
+        Generic.Subheading:        "",         # class: 'gu'
+        Generic.Traceback:         "",         # class: 'gt'
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/coffee.py

@@ -0,0 +1,80 @@
+"""
+    pygments.styles.coffee
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    A warm and cozy theme based off gruvbox
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import (Comment, Error, Generic, Keyword, Literal, Name,
+                            Number, Operator, Punctuation, String, Token)
+
+__all__ = ["CoffeeStyle"]
+
+
+class CoffeeStyle(Style):
+    """
+    A warm and cozy theme based off gruvbox
+    """
+
+    name = "coffee"
+
+    background_color = "#262220"
+    highlight_color = "#ddd0c0"
+
+    line_number_color = "#4e4e4e"
+    line_number_special_color = "#8f9494"
+
+    styles = {
+        Comment: "#70757A",
+        Comment.Hashbang: "#8f9f9f",
+        Comment.Preproc: "#fdd0c0",
+        Comment.PreprocFile: "#c9b98f",
+        Comment.Special: "#af5f5f",
+        Error: "#af5f5f",
+        Generic.Deleted: "#bb6868",
+        Generic.Emph: "italic",
+        Generic.Error: "#af5f5f",
+        Generic.Inserted: "#849155",
+        Generic.Output: "#ddd0c0",
+        Generic.Strong: "bold",
+        Generic.Traceback: "#af5f5f",
+        Keyword: "#919191",
+        Keyword.Constant: "#875f5f",
+        Keyword.Declaration: "#875f5f",
+        Keyword.Namespace: "#875f5f",
+        Keyword.Reserved: "#b46276",
+        Keyword.Type: "#af875f",
+        Literal: "#af875f",
+        Name: "#ddd0c0",
+        Name.Attribute: "#ddd0c0",
+        Name.Builtin: "#ddd0c0",
+        Name.Builtin.Pseudo: "#87afaf",
+        Name.Class: "#875f5f",
+        Name.Constant: "#af8787",
+        Name.Decorator: "#fdd0c0",
+        Name.Entity: "#ddd0c0",
+        Name.Exception: "#877575",
+        Name.Function: "#fdd0c0",
+        Name.Function.Magic: "#fdd0c0",
+        Name.Other: "#ddd0c0",
+        Name.Property: "#dfaf87",
+        Name.Tag: "#87afaf",
+        Name.Variable: "#ddd0c0",
+        Number: "#87afaf",
+        Operator: "#878787",
+        Operator.Word: "#878787",
+        Punctuation: "#ddd0c0",
+        String: "#c9b98f",
+        String.Affix: "#dfaf87",
+        String.Doc: "#878787",
+        String.Escape: "#af5f5f",
+        String.Interpol: "#af5f5f",
+        String.Other: "#fdd0c0",
+        String.Regex: "#af5f5f",
+        String.Symbol: "#af5f5f",
+        Token: "#ddd0c0",
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/dracula.py

@@ -0,0 +1,90 @@
+"""
+    pygments.styles.dracula
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Pygments version of `Dracula` from https://github.com/dracula/dracula-theme.
+
+    Based on the Dracula Theme for pygments by Chris Bracco.
+    See https://github.com/dracula/pygments/tree/fee9ed5613d1086bc01b9d0a5a0e9867a009f571
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, Literal, \
+    Number, Operator, Other, Punctuation, Text, Generic, Whitespace
+
+
+__all__ = ['DraculaStyle']
+
+background = "#282a36"
+foreground = "#f8f8f2"
+selection = "#44475a"
+comment = "#6272a4"
+cyan = "#8be9fd"
+green = "#50fa7b"
+orange = "#ffb86c"
+pink = "#ff79c6"
+purple = "#bd93f9"
+red = "#ff5555"
+yellow = "#f1fa8c"
+
+deletion = "#8b080b"
+
+class DraculaStyle(Style):
+    name = 'dracula'
+
+    background_color = background
+    highlight_color = selection
+    line_number_color = yellow
+    line_number_background_color = selection
+    line_number_special_color = green
+    line_number_special_background_color = comment
+
+    styles = {
+        Whitespace: foreground,
+
+        Comment: comment,
+        Comment.Preproc: pink,
+
+        Generic: foreground,
+        Generic.Deleted: deletion,
+        Generic.Emph: "underline",
+        Generic.Heading: "bold",
+        Generic.Inserted: "bold",
+        Generic.Output: selection,
+        Generic.EmphStrong: "underline",
+        Generic.Subheading: "bold",
+
+        Error: foreground,
+
+        Keyword: pink,
+        Keyword.Constant: pink,
+        Keyword.Declaration: cyan + " italic",
+        Keyword.Type: cyan,
+
+        Literal: foreground,
+
+        Name: foreground,
+        Name.Attribute: green,
+        Name.Builtin: cyan + " italic",
+        Name.Builtin.Pseudo: foreground,
+        Name.Class: green,
+        Name.Function: green,
+        Name.Label: cyan + " italic",
+        Name.Tag: pink,
+        Name.Variable: cyan + " italic",
+
+        Number: orange,
+
+        Operator: pink,
+
+        Other: foreground,
+
+        Punctuation: foreground,
+
+        String: purple,
+
+        Text: foreground,
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/gh_dark.py

@@ -0,0 +1,113 @@
+"""
+    pygments.styles.gh_dark
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Github's Dark-Colorscheme based theme for Pygments
+    Colors extracted from https://github.com/primer/primitives
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, Error, Number, Operator, \
+    Generic, Text, Literal, String, Token
+
+
+__all__ = ['GhDarkStyle']
+
+
+# vars are defined to match the defs in
+# - [GitHub's VS Code theme](https://github.com/primer/github-vscode-theme) and
+# - [Primer styles](https://github.com/primer/primitives)
+RED_2 = "#ffa198"
+RED_3 = "#ff7b72"
+RED_9 = "#490202"
+ORANGE_2 = "#ffa657"
+ORANGE_3 = "#f0883e"
+GREEN_1 = "#7ee787"
+GREEN_2 = "#56d364"
+GREEN_7 = "#0f5323"
+BLUE_1 = "#a5d6ff"
+BLUE_2 = "#79c0ff"
+PURPLE_2 = "#d2a8ff"
+GRAY_3 = "#8b949e"
+GRAY_4 = "#6e7681"
+FG_SUBTLE = "#6e7681"
+FG_DEFAULT = "#e6edf3"
+BG_DEFAULT = "#0d1117"
+DANGER_FG = "#f85149"
+
+
+class GhDarkStyle(Style):
+    """
+    Github's Dark-Colorscheme based theme for Pygments
+    """
+    
+    name = 'github-dark'
+
+    background_color = BG_DEFAULT
+
+    # has transparency in VS Code theme as `colors.codemirror.activelineBg`
+    highlight_color = GRAY_4
+
+    line_number_special_color = FG_DEFAULT
+    line_number_special_background_color = FG_SUBTLE
+
+    line_number_color = GRAY_4
+    line_number_background_color = BG_DEFAULT
+
+    styles = {
+        Token:                      FG_DEFAULT,
+
+        Error:                      DANGER_FG,
+
+        Keyword:                    RED_3,
+        Keyword.Constant:           BLUE_2,
+        Keyword.Pseudo:             BLUE_2,
+
+        Name:                       FG_DEFAULT,
+        Name.Class:                 "bold "+ORANGE_3,
+        Name.Constant:              "bold "+BLUE_2,
+        Name.Decorator:             'bold '+PURPLE_2,
+        Name.Entity:                ORANGE_2,
+        Name.Exception:             "bold "+ORANGE_3,
+        Name.Function:              'bold '+PURPLE_2,
+        Name.Label:                 "bold "+BLUE_2,
+        Name.Namespace:             RED_3,
+        Name.Property:              BLUE_2,
+        Name.Tag:                   GREEN_1,
+        Name.Variable:              BLUE_2,
+
+        Literal:                    BLUE_1,
+        Literal.Date:               BLUE_2,
+        String:                     BLUE_1,
+        String.Affix:               BLUE_2,
+        String.Delimiter:           BLUE_2,
+        String.Escape:              BLUE_2,
+        String.Heredoc:             BLUE_2,
+        String.Regex:               BLUE_2,
+        Number:                     BLUE_1,
+
+        Comment:                    'italic '+GRAY_3,
+        Comment.Preproc:            "bold " + GRAY_3,
+        Comment.Special:            "bold italic " + GRAY_3,
+
+        Operator:                   'bold ' + RED_3,
+
+        Generic:                    FG_DEFAULT,
+        Generic.Deleted:            f"bg:{RED_9} {RED_2}",
+        Generic.Emph:               "italic",
+        Generic.Error:              RED_2,
+        Generic.Heading:            "bold "+BLUE_2,
+        Generic.Inserted:           f'bg:{GREEN_7} {GREEN_2}',
+        Generic.Output:             GRAY_3,
+        Generic.Prompt:             GRAY_3,
+        Generic.Strong:             "bold",
+        Generic.EmphStrong:         "bold italic",
+        Generic.Subheading:         BLUE_2,
+        Generic.Traceback:          RED_3,
+        Generic.Underline:          "underline",
+
+        Text.Whitespace:            FG_SUBTLE,
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/lightbulb.py

@@ -0,0 +1,110 @@
+"""
+    pygments.styles.lightbulb
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    A minimal dark theme based on the Lightbulb theme for VSCode.
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import (
+    Comment,
+    Error,
+    Generic,
+    Keyword,
+    Literal,
+    Name,
+    Number,
+    Operator,
+    Punctuation,
+    String,
+    Token,
+)
+
+
+__all__ = ['LightbulbStyle']
+
+
+COLORS = {
+    "bg": "#1d2331",
+    "blue_1": "#73D0FF",
+    "gray_1": "#7e8aa1",
+    "gray_2": "#3c4354",
+    "gray_3": "#6e7681",
+    "red_1": "#f88f7f",
+    "red_2": "#3d1e20",
+    "orange_1": "#FFAD66",
+    "orange_2": "#F29E74",
+    "yellow_1": "#FFD173",
+    "white": "#d4d2c8",
+    "magenta_1": "#DFBFFF",
+    "green_1": "#D5FF80",
+    "green_2": "#19362c",
+    "cyan_1": "#95E6CB",
+}
+
+
+class LightbulbStyle(Style):
+    """
+    A minimal dark theme based on the Lightbulb theme for VSCode.
+    """
+
+    name = 'lightbulb'
+
+    background_color = COLORS['bg']
+    highlight_color = COLORS['gray_3']
+
+    line_number_color = COLORS['gray_2']
+    line_number_special_color = COLORS['gray_2']
+
+    styles = {
+        Comment: COLORS["gray_1"],
+        Comment.Hashbang: "italic " + COLORS['red_1'],
+        Comment.Preproc: "bold " + COLORS['orange_1'],
+        Comment.Special: "italic " + COLORS['gray_1'],
+        Error: COLORS['red_1'],
+        Generic.Deleted: f"bg:{COLORS['red_2']} #f88f7f",
+        Generic.Emph: "italic",
+        Generic.Error: "#f88f7f",
+        Generic.Inserted: f"bg:{COLORS['green_2']} #6ad4af",
+        Generic.Output: COLORS['gray_1'],
+        Generic.Strong: "bold",
+        Generic.Traceback: COLORS['red_1'],
+        Keyword: COLORS['orange_1'],
+        Keyword.Constant: COLORS['orange_1'],
+        Keyword.Declaration: COLORS['orange_1'],
+        Keyword.Namespace: COLORS['orange_1'],
+        Keyword.Reserved: COLORS['orange_1'],
+        Keyword.Type: COLORS['blue_1'],
+        Literal: COLORS['green_1'],
+        Name: COLORS['white'],
+        Name.Attribute: COLORS['yellow_1'],
+        Name.Builtin: COLORS['yellow_1'],
+        Name.Builtin.Pseudo: "#5CCFE6",
+        Name.Class: COLORS['blue_1'],
+        Name.Constant: COLORS['yellow_1'],
+        Name.Decorator: "bold italic " + COLORS['gray_1'],
+        Name.Entity: COLORS['cyan_1'],
+        Name.Exception: COLORS['blue_1'],
+        Name.Function: COLORS['yellow_1'],
+        Name.Function.Magic: COLORS['yellow_1'],
+        Name.Other: COLORS['white'],
+        Name.Property: COLORS['yellow_1'],
+        Name.Tag: "#5CCFE6",
+        Name.Variable: COLORS['white'],
+        Number: COLORS['magenta_1'],
+        Operator: COLORS['orange_1'],
+        Operator.Word: COLORS['orange_1'],
+        Punctuation: COLORS['white'],
+        String: COLORS['green_1'],
+        String.Affix: COLORS['orange_2'],
+        String.Doc: COLORS['gray_1'],
+        String.Escape: COLORS['cyan_1'],
+        String.Interpol: COLORS['cyan_1'],
+        String.Other: COLORS['cyan_1'],
+        String.Regex: COLORS['cyan_1'],
+        String.Symbol: COLORS['magenta_1'],
+        Token: COLORS['white'],
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/nord.py

@@ -0,0 +1,156 @@
+"""
+    pygments.styles.nord
+    ~~~~~~~~~~~~~~~~~~~~
+
+    pygments version of the "nord" theme by Arctic Ice Studio
+    https://www.nordtheme.com/
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, Number, \
+    Operator, Generic, Whitespace, Punctuation, Text, Token
+
+
+__all__ = ['NordStyle', 'NordDarkerStyle']
+
+
+class NordStyle(Style):
+    """
+    Pygments version of the "nord" theme by Arctic Ice Studio.
+    """
+    name = 'nord'
+    
+    line_number_color = "#D8DEE9"
+    line_number_background_color = "#242933"
+    line_number_special_color = "#242933"
+    line_number_special_background_color = "#D8DEE9"
+
+    background_color = "#2E3440"
+    highlight_color = "#3B4252"
+
+    styles = {
+        Token:                      "#d8dee9",
+
+        Whitespace:                 '#d8dee9',
+        Punctuation:                '#eceff4',
+
+        Comment:                    'italic #616e87',
+        Comment.Preproc:            '#5e81ac',
+
+        Keyword:                    'bold #81a1c1',
+        Keyword.Pseudo:             'nobold #81a1c1',
+        Keyword.Type:               'nobold #81a1c1',
+
+        Operator:                   'bold #81a1c1',
+        Operator.Word:              'bold #81a1c1',
+
+        Name:                       '#d8dee9',
+        Name.Builtin:               '#81a1c1',
+        Name.Function:              '#88c0d0',
+        Name.Class:                 '#8fbcbb',
+        Name.Namespace:             '#8fbcbb',
+        Name.Exception:             '#bf616a',
+        Name.Variable:              '#d8dee9',
+        Name.Constant:              '#8fbcbb',
+        Name.Entity:                '#d08770',
+        Name.Attribute:             '#8fbcbb',
+        Name.Tag:                   '#81a1c1',
+        Name.Decorator:             '#d08770',
+
+        String:                     '#a3be8c',
+        String.Doc:                 '#616e87',
+        String.Interpol:            '#a3be8c',
+        String.Escape:              '#ebcb8b',
+        String.Regex:               '#ebcb8b',
+        String.Symbol:              '#a3be8c',
+        String.Other:               '#a3be8c',
+
+        Number:                     '#b48ead',
+
+        Generic.Heading:            'bold #88c0d0',
+        Generic.Subheading:         'bold #88c0d0',
+        Generic.Deleted:            '#bf616a',
+        Generic.Inserted:           '#a3be8c',
+        Generic.Error:              '#bf616a',
+        Generic.Emph:               'italic',
+        Generic.Strong:             'bold',
+        Generic.EmphStrong:         'bold italic',
+        Generic.Prompt:             'bold #616e88',
+        Generic.Output:             '#d8dee9',
+        Generic.Traceback:          '#bf616a',
+
+        Error:                      '#bf616a',
+        Text:                       '#d8dee9',
+    }
+
+
+class NordDarkerStyle(Style):
+    """
+    Pygments version of a darker "nord" theme by Arctic Ice Studio
+    """
+    name = 'nord-darker'
+    
+    line_number_color = "#D8DEE9"
+    line_number_background_color = "#242933"
+    line_number_special_color = "#242933"
+    line_number_special_background_color = "#D8DEE9"
+
+    background_color = "#242933"
+    highlight_color = "#3B4252"
+
+    styles = {
+        Token:                      "#d8dee9",
+
+        Whitespace:                 '#d8dee9',
+        Punctuation:                '#eceff4',
+
+        Comment:                    'italic #616e87',
+        Comment.Preproc:            '#5e81ac',
+
+        Keyword:                    'bold #81a1c1',
+        Keyword.Pseudo:             'nobold #81a1c1',
+        Keyword.Type:               'nobold #81a1c1',
+
+        Operator:                   'bold #81a1c1',
+        Operator.Word:              'bold #81a1c1',
+
+        Name:                       '#d8dee9',
+        Name.Builtin:               '#81a1c1',
+        Name.Function:              '#88c0d0',
+        Name.Class:                 '#8fbcbb',
+        Name.Namespace:             '#8fbcbb',
+        Name.Exception:             '#bf616a',
+        Name.Variable:              '#d8dee9',
+        Name.Constant:              '#8fbcbb',
+        Name.Entity:                '#d08770',
+        Name.Attribute:             '#8fbcbb',
+        Name.Tag:                   '#81a1c1',
+        Name.Decorator:             '#d08770',
+
+        String:                     '#a3be8c',
+        String.Doc:                 '#616e87',
+        String.Interpol:            '#a3be8c',
+        String.Escape:              '#ebcb8b',
+        String.Regex:               '#ebcb8b',
+        String.Symbol:              '#a3be8c',
+        String.Other:               '#a3be8c',
+
+        Number:                     '#b48ead',
+
+        Generic.Heading:            'bold #88c0d0',
+        Generic.Subheading:         'bold #88c0d0',
+        Generic.Deleted:            '#bf616a',
+        Generic.Inserted:           '#a3be8c',
+        Generic.Error:              '#bf616a',
+        Generic.Emph:               'italic',
+        Generic.Strong:             'bold',
+        Generic.Prompt:             'bold #616e88',
+        Generic.Output:             '#d8dee9',
+        Generic.Traceback:          '#bf616a',
+
+        Error:                      '#bf616a',
+        Text:                       '#d8dee9',
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/paraiso_light.py

@@ -0,0 +1,124 @@
+"""
+    pygments.styles.paraiso_light
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Paraíso (Light) by Jan T. Sott
+
+    Pygments template by Jan T. Sott (https://github.com/idleberg)
+    Created with Base16 Builder by Chris Kempson
+    (https://github.com/chriskempson/base16-builder).
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, Text, \
+    Number, Operator, Generic, Whitespace, Punctuation, Other, Literal
+
+
+__all__ = ['ParaisoLightStyle']
+
+
+BACKGROUND = "#e7e9db"
+CURRENT_LINE = "#b9b6b0"
+SELECTION = "#a39e9b"
+FOREGROUND = "#2f1e2e"
+COMMENT = "#8d8687"
+RED = "#ef6155"
+ORANGE = "#f99b15"
+YELLOW = "#fec418"
+GREEN = "#48b685"
+AQUA = "#5bc4bf"
+BLUE = "#06b6ef"
+PURPLE = "#815ba4"
+
+
+class ParaisoLightStyle(Style):
+    name = 'paraiso-light'
+    
+    background_color = BACKGROUND
+    highlight_color = SELECTION
+
+    styles = {
+        # No corresponding class for the following:
+        Text:                      FOREGROUND,  # class:  ''
+        Whitespace:                "",          # class: 'w'
+        Error:                     RED,         # class: 'err'
+        Other:                     "",          # class 'x'
+
+        Comment:                   COMMENT,   # class: 'c'
+        Comment.Multiline:         "",        # class: 'cm'
+        Comment.Preproc:           "",        # class: 'cp'
+        Comment.Single:            "",        # class: 'c1'
+        Comment.Special:           "",        # class: 'cs'
+
+        Keyword:                   PURPLE,    # class: 'k'
+        Keyword.Constant:          "",        # class: 'kc'
+        Keyword.Declaration:       "",        # class: 'kd'
+        Keyword.Namespace:         AQUA,      # class: 'kn'
+        Keyword.Pseudo:            "",        # class: 'kp'
+        Keyword.Reserved:          "",        # class: 'kr'
+        Keyword.Type:              YELLOW,    # class: 'kt'
+
+        Operator:                  AQUA,      # class: 'o'
+        Operator.Word:             "",        # class: 'ow' - like keywords
+
+        Punctuation:               FOREGROUND,  # class: 'p'
+
+        Name:                      FOREGROUND,  # class: 'n'
+        Name.Attribute:            BLUE,        # class: 'na' - to be revised
+        Name.Builtin:              "",          # class: 'nb'
+        Name.Builtin.Pseudo:       "",          # class: 'bp'
+        Name.Class:                YELLOW,      # class: 'nc' - to be revised
+        Name.Constant:             RED,         # class: 'no' - to be revised
+        Name.Decorator:            AQUA,        # class: 'nd' - to be revised
+        Name.Entity:               "",          # class: 'ni'
+        Name.Exception:            RED,         # class: 'ne'
+        Name.Function:             BLUE,        # class: 'nf'
+        Name.Property:             "",          # class: 'py'
+        Name.Label:                "",          # class: 'nl'
+        Name.Namespace:            YELLOW,      # class: 'nn' - to be revised
+        Name.Other:                BLUE,        # class: 'nx'
+        Name.Tag:                  AQUA,        # class: 'nt' - like a keyword
+        Name.Variable:             RED,         # class: 'nv' - to be revised
+        Name.Variable.Class:       "",          # class: 'vc' - to be revised
+        Name.Variable.Global:      "",          # class: 'vg' - to be revised
+        Name.Variable.Instance:    "",          # class: 'vi' - to be revised
+
+        Number:                    ORANGE,    # class: 'm'
+        Number.Float:              "",        # class: 'mf'
+        Number.Hex:                "",        # class: 'mh'
+        Number.Integer:            "",        # class: 'mi'
+        Number.Integer.Long:       "",        # class: 'il'
+        Number.Oct:                "",        # class: 'mo'
+
+        Literal:                   ORANGE,    # class: 'l'
+        Literal.Date:              GREEN,     # class: 'ld'
+
+        String:                    GREEN,       # class: 's'
+        String.Backtick:           "",          # class: 'sb'
+        String.Char:               FOREGROUND,  # class: 'sc'
+        String.Doc:                COMMENT,     # class: 'sd' - like a comment
+        String.Double:             "",          # class: 's2'
+        String.Escape:             ORANGE,      # class: 'se'
+        String.Heredoc:            "",          # class: 'sh'
+        String.Interpol:           ORANGE,      # class: 'si'
+        String.Other:              "",          # class: 'sx'
+        String.Regex:              "",          # class: 'sr'
+        String.Single:             "",          # class: 's1'
+        String.Symbol:             "",          # class: 'ss'
+
+        Generic:                   "",                    # class: 'g'
+        Generic.Deleted:           RED,                   # class: 'gd',
+        Generic.Emph:              "italic",              # class: 'ge'
+        Generic.Error:             "",                    # class: 'gr'
+        Generic.Heading:           "bold " + FOREGROUND,  # class: 'gh'
+        Generic.Inserted:          GREEN,                 # class: 'gi'
+        Generic.Output:            "",                    # class: 'go'
+        Generic.Prompt:            "bold " + COMMENT,     # class: 'gp'
+        Generic.Strong:            "bold",                # class: 'gs'
+        Generic.EmphStrong:        "bold italic",         # class: 'ges'
+        Generic.Subheading:        "bold " + AQUA,        # class: 'gu'
+        Generic.Traceback:         "",                    # class: 'gt'
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/stata_dark.py

@@ -0,0 +1,42 @@
+"""
+    pygments.styles.stata_dark
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Dark style inspired by Stata's do-file editor. Note this is not
+    meant to be a complete style, just for Stata's file formats.
+
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Token, Keyword, Name, Comment, String, Error, \
+    Number, Operator, Whitespace, Generic
+
+
+__all__ = ['StataDarkStyle']
+
+
+class StataDarkStyle(Style):
+    name = 'stata-dark'
+    
+    background_color = "#232629"
+    highlight_color = "#49483e"
+
+    styles = {
+        Token:                 '#cccccc',
+        Whitespace:            '#bbbbbb',
+        Error:                 'bg:#e3d2d2 #a61717',
+        String:                '#51cc99',
+        Number:                '#4FB8CC',
+        Operator:              '',
+        Name.Function:         '#6a6aff',
+        Name.Other:            '#e2828e',
+        Keyword:               'bold #7686bb',
+        Keyword.Constant:      '',
+        Comment:               'italic #777777',
+        Name.Variable:         'bold #7AB4DB',
+        Name.Variable.Global:  'bold #BE646C',
+        Generic.Prompt:        '#ffffff',
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/stata_light.py

@@ -0,0 +1,42 @@
+"""
+    pygments.styles.stata_light
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Light Style inspired by Stata's do-file editor. Note this is not
+    meant to be a complete style, just for Stata's file formats.
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Keyword, Name, Comment, String, Error, \
+    Number, Operator, Whitespace, Text
+
+
+__all__ = ['StataLightStyle']
+
+
+class StataLightStyle(Style):
+    """
+    Light mode style inspired by Stata's do-file editor. This is not
+    meant to be a complete style, just for use with Stata.
+    """
+
+    name = 'stata-light'
+    
+    styles = {
+        Text:                  '#111111',
+        Whitespace:            '#bbbbbb',
+        Error:                 'bg:#e3d2d2 #a61717',
+        String:                '#7a2424',
+        Number:                '#2c2cff',
+        Operator:              '',
+        Name.Function:         '#2c2cff',
+        Name.Other:            '#be646c',
+        Keyword:               'bold #353580',
+        Keyword.Constant:      '',
+        Comment:               'italic #008800',
+        Name.Variable:         'bold #35baba',
+        Name.Variable.Global:  'bold #b5565e',
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/pygments/styles/zenburn.py

@@ -0,0 +1,83 @@
+"""
+    pygments.styles.zenburn
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Low contrast color scheme Zenburn.
+
+    See: https://kippura.org/zenburnpage/
+         https://github.com/jnurmine/Zenburn
+
+    :copyright: Copyright 2006-present by the Pygments team, see AUTHORS.
+    :license: BSD, see LICENSE for details.
+"""
+
+from pygments.style import Style
+from pygments.token import Token, Name, Operator, Keyword, Generic, Comment, \
+    Number, String, Literal, Punctuation, Error
+
+
+__all__ = ['ZenburnStyle']
+
+
+class ZenburnStyle(Style):
+    """
+    Low contrast Zenburn style.
+    """
+
+    name = 'zenburn'
+    
+    background_color = '#3f3f3f'
+    highlight_color = '#484848'
+    line_number_color = '#5d6262'
+    line_number_background_color = '#353535'
+    line_number_special_color = '#7a8080'
+    line_number_special_background_color = '#353535'
+
+    styles = {
+        Token: '#dcdccc',
+        Error: '#e37170 bold',
+
+        Keyword: '#efdcbc',
+        Keyword.Type: '#dfdfbf bold',
+        Keyword.Constant: '#dca3a3',
+        Keyword.Declaration: '#f0dfaf',
+        Keyword.Namespace: '#f0dfaf',
+
+        Name: '#dcdccc',
+        Name.Tag: '#e89393 bold',
+        Name.Entity: '#cfbfaf',
+        Name.Constant: '#dca3a3',
+        Name.Class: '#efef8f',
+        Name.Function: '#efef8f',
+        Name.Builtin: '#efef8f',
+        Name.Builtin.Pseudo: '#dcdccc',
+        Name.Attribute: '#efef8f',
+        Name.Exception: '#c3bf9f bold',
+
+        Literal: '#9fafaf',
+
+        String: '#cc9393',
+        String.Doc: '#7f9f7f',
+        String.Interpol: '#dca3a3 bold',
+
+        Number: '#8cd0d3',
+        Number.Float: '#c0bed1',
+
+        Operator: '#f0efd0',
+
+        Punctuation: '#f0efd0',
+
+        Comment: '#7f9f7f italic',
+        Comment.Preproc: '#dfaf8f bold',
+        Comment.PreprocFile: '#cc9393',
+        Comment.Special: '#dfdfdf bold',
+
+        Generic: '#ecbcbc bold',
+        Generic.Emph: '#ffffff bold',
+        Generic.Output: '#5b605e bold',
+        Generic.Heading: '#efefef bold',
+        Generic.Deleted: '#c3bf9f bg:#313c36',
+        Generic.Inserted: '#709080 bg:#313c36 bold',
+        Generic.Traceback: '#80d4aa bg:#2f2f2f bold',
+        Generic.Subheading: '#efefef bold',
+    }

LTA_openwebtext_dualt/mini_owt_logdirichlet/cache/qwen36_35b_owt_worst20_rewrite/accepted.jsonl

@@ -0,0 +1,20 @@
+{"doc_idx": 8304, "chunk_idx": 2, "raw_sha1": "f14ddb3c95a1e35ca40f7b0755c199850a100bb6", "raw_chars": 14, "clean_chars": 10, "edit_ratio": 0.1667, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "For me, it", "reject_reason": ""}
+{"doc_idx": 9444, "chunk_idx": 1, "raw_sha1": "1f1134f0b3981e612424d545bad1fa9382b90178", "raw_chars": 1627, "clean_chars": 1640, "edit_ratio": 0.0077, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "We are shocked, please give us some time – Yadav on forming a new party. These tendencies have now taken an ugly turn - Bhushan. I have been telling Arvind Kejriwal he has dictatorial tendencies and he needs to curb those - Bhushan. I have 40 years of experience behind me. I know what democracy is, I know the values - Dharamvir Gandhi. Volunteers have to think: is it the party, the movement they had worked for - Bhushan. Admiral Ramdas sent a text back saying he was surprised to know that he could cause confrontation - Bhushan. Lokpal Admiral Ramdas was told, 'Your term has expired' - Bhushan. Also Read: AAP draws flak, ridicule over infighting. We had told them it must be ensured that the meeting be video-graphed, and voting to take place through a secret ballot - Bhushan. Each MLA was asked to bring along some 50 MLAs with them for today's meet - Bhushan. Through this entire rift, Dr Dharamvir Gandhi did not side with anyone, but what happened today wasn't acceptable to him as well - Yadav. I request people not to judge us, our party by what happened today - Yadav. Arvind bhai ended his speech in a dramatic matter and left by saying he had to attend an important meeting - Yadav. I went to Arvind ji and Manish ji and said look NC members are being beaten up; Arvind ji just stood there - Yadav. Ramzan Chaudhry had only said “please listen to the duo as well” and he was then beaten up and dragged by two bouncers - Yadav. Arvind said in his speech, “I can't work with these people, you decide who you want to work with” - Yadav. It was an orchestrated performance at the NC meet - Yadav. MLAs were shouting “gaddaron k", "reject_reason": ""}
+{"doc_idx": 9444, "chunk_idx": 0, "raw_sha1": "3b1e771eeb5d5ffbd96c0d0e4f82901c1acb3b00", "raw_chars": 1888, "clean_chars": 2022, "edit_ratio": 0.1918, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Prashant Bhushan.\n\n\"They were treated unfairly,\" she said.\n\nArvind Kejriwal has, meanwhile, returned to the National Council meeting venue in Kapashera, say reports.\n\n\"Arvind and his gang are a bunch of uncouth goons,\" said Shazia Ilmi. \"They (Yogendra Yadav and Prashant Bhushan) have been thrown out unceremoniously, it's disgusting.\"\n\n\"This is political 'goondaism' at its worst,\" said Shazia Ilmi. \"Arvind will leave no stone unturned to show the way out to people who raise their voice of dissent.\"\n\n\"He wants power by hook or crook, and he can do anything to get there,\" said Shazia Ilmi. \"This has not come as a shock to me.\"\n\n\"I know exactly what kind of political 'goondaism' they can resort to,\" said BJP's Shazia Ilmi. \"This is AAP's internal matter, why would I get into it?\"\n\n\"It's beyond my understanding,\" said Anna Hazare. Also Read: Anna Hazare refuses to get involved in AAP's internal dissent, says it's beyond his understanding.\n\n\"This is nothing new. Anyone who raises a voice against the supremo of AAP, they are shown the way out,\" said Satish Upadhyay (BJP).\n\n\"I was also inside (the venue of the meeting), nothing of that sort (violence) happened,\" said Satyendra Jain.\n\n\"There were allegations against us that we were planning to float a separate party. If someone else talks about forming a new party, then it's a crime, but if Arvind bhai talks about the same then it is not,\" said Yadav.\n\n\"I got to know last night that Kejriwal himself is planning to float a new party,\" said Yadav.\n\n\"It is true that the meeting was unconstitutional and unlawful,\" said Bhushan.\n\n\"Now, what we will do to challenge it is yet to be decided,\" said Bhushan.\n\n\"Volunteers have sacrificed a lot for this party,\" said Yadav.\n\n\"I repeat, please don't judge AAP by what happened at National Council,\" said Yadav.\n\n\"National Council has 400 members, but they could manage signatures of only 167 members on the resolution. This hints at something,\" said Yadav.\n\n\"We didn't have any script, they had prepared a script.\"", "reject_reason": ""}
+{"doc_idx": 8304, "chunk_idx": 0, "raw_sha1": "654cfa9ea0e5200e9e3d8c23bb2f8301b0a73b79", "raw_chars": 1983, "clean_chars": 1985, "edit_ratio": 0.0005, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "It's been fun.\n\nESPN.com: As a basketball player, how important are your socks?\n\nRobinson: Oh, man, it's big-time.\n\nTrust me.\n\nI've been around where you have uncomfortable socks, and they just don't feel right.\n\nIt's like, 'Ugh,' it's like a drag.\n\nThis is a game-changer.\n\nSay you're in the hotel and you don't want to run out of the room with your wallet.\n\nYou can put your hotel room key in your sock or your money and run downstairs right quick.\n\nIt's not deactivating because you put your key by your phone.\n\nThere are different perks to the whole pocket sock.\n\nI think it's pretty cool.\n\nWe're dropping it on April 23, and it's kind of a big deal for us.\n\nESPN.com: So fans can get involved by supporting the Kickstarter?\n\nRobinson: Yeah, pretty much.\n\nTrying to push that and get that going and get fans excited.\n\nWe'll get the socks to you early.\n\nIt's going to be pretty fun to see how it turns out.\n\nPlaying ball in Israel ESPN.com: What made you decide to go play in Israel?\n\nRobinson: Just to stay in shape, to play alongside my guy Tre Simmons, who went to college with me at UW.\n\nI get to play on his team.\n\nTo get away from home a little bit and just play, have fun and stay in shape.\n\nYou never know when your name is going to be called.\n\nESPN.com: We saw video of fans celebrating your arrival at the airport.\n\nHow has their support been?\n\nRobinson: It's pretty crazy.\n\nThe fans are big-time fans, man.\n\nI love how excited they are about the players.\n\nThey love it here.\n\nThey love the American players, what you bring to the table.\n\nMe being the player that I am, those fans are just the same.\n\nThey're just like me.\n\nESPN.com: Hapoel has gone 4-2 since your arrival to move into a playoff spot.\n\nDo you think you've helped?\n\nRobinson: I think I have.\n\nJust bringing a different culture of basketball to them.\n\nThe coach, he loves how intense I am in practice because it pushes the guys.\n\nA little bit of trash-talking can get guys excited about playing in practice.", "reject_reason": ""}
+{"doc_idx": 8304, "chunk_idx": 1, "raw_sha1": "543a620d995b38e0ac6a817edd9afd8dd2405297", "raw_chars": 1991, "clean_chars": 1991, "edit_ratio": 0.0, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "He's letting me bring new plays in, what I think can help the team.\n\nIt's been pretty fun.\n\nESPN.com: How does the game on the court compare to your NBA experience?\n\nRobinson: The level of play's high.\n\nIt's high-level.\n\nThey don't call the touch fouls like when James Harden gets touched and he gets an and-one every time.\n\nYou've got to get fouled over here.\n\nESPN.com: Had you been to Israel?\n\nRobinson: No, this is my first time.\n\nESPN.com: What's the adjustment been like off the court?\n\nRobinson: Off the court ...\n\nnot really too much of an adjustment.\n\nThe weather is nice.\n\nThe food is great.\n\nIt's Americanized.\n\nThey've got great food, great culture here.\n\nThe people here are cool.\n\nThe food is awesome, though.\n\nI love the food.\n\nEating has been my favorite thing to do out here.\n\nESPN.com: What do you miss most being overseas?\n\nRobinson: My family.\n\nI miss my family the most, being home.\n\nI miss the Seattle rain.\n\nI miss the time difference.\n\nRight now it's nighttime [here], and it's daytime where you guys are at.\n\nTime to wind down now to get some rest, but I haven't been getting that much sleep.\n\nThe NBA games are on late at night for us -- 3, 4 in the morning.\n\n[I'm] trying to stay up and watch them.\n\nI fell asleep watching a couple of games.\n\nESPN.com: How serious are you about pursuing the NFL?\n\nRobinson: Serious as a heart attack.\n\nTotally serious.\n\nAs soon as I get the opportunity, if it comes my way, I'll take full advantage of it.\n\n\"The biggest challenge is probably all the haters, everybody counting me out, somebody not really giving me the opportunity.\" Nate Robinson, on hopes of joining NFL ESPN.com: Is playing in the NFL a dream of yours?\n\nRobinson: It's a big-time dream.\n\nSomething I've always wanted to do, play both sports at the highest level.\n\nWe'll see if I can be the first one to really do it.\n\nESPN.com: Was it difficult to give up football after your freshman year at University of Washington?\n\nRobinson: Kind of.\n\nIt was kind of tough.", "reject_reason": ""}
+{"doc_idx": 2840, "chunk_idx": 0, "raw_sha1": "71d0f12edd4263fe04dba65f5065f739fee11de6", "raw_chars": 1862, "clean_chars": 1825, "edit_ratio": 0.169, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Sleep is not allowed. The crowd will be encouraged to chant \"SHAME. SHAME. SHAME. SHAME\" for the entire round. Admission would be free and open, allowing fresh hecklers to fill in and yell throughout the 41-hour process. In hour five, a limping, bedraggled Bonds would want to give up this foolish quest, to sign away the rights to the millions he was promised, to forget about the Hall of Fame. He would declare himself the winner after 278 home runs, begging for mercy. The crowd would chant \"SHAME. SHAME. SHAME. SHAME\" behind him, impervious to his pleas, acting like the bloodthirsty rabble behind Q during Picard's trial, shaking fists and half-eaten legs of mutton, possibly throwing the bones on the field when they're done. \"SHAME. SHAME. SHAME. SHAME,\" they would cry. And after a rest, Bonds would use his bat as support while he stood up, and then he would hit more dingers. After each home run, the crowd would roar a bloodthirsty, guttural roar and then start chanting again. \"SHAME. SHAME. SHAME. SHAME.\" Mark McGwire, hands blistered, lips cracked from the merciless sun, slowly walking up to take his five swings. \"SHAME. SHAME. SHAME. SHAME.\" Barry Bonds, eyes closed, hoping to find a reserve of strength he didn't know existed, a secret wellspring of power, now, when he needs it most. \"SHAME. SHAME. SHAME. SHAME.\" Someone would win. Someone would have to. Round Three format: After the participant reaches 1000 homers, he will collapse on the field, bloody, exhausted, and openly weeping. He will think he's victorious, that his nightmare is over. That's when they would play Jose Canseco's music. /K-Pop beat and vocals \"It's Jose Canseeeeeeco Jose, can you see? Can you see Jose? I can see Jose Jose Canseeeeeeco\" Okay, Jose Canseco doesn't have music yet, but the exact song can be figured out later.", "reject_reason": ""}
+{"doc_idx": 4393, "chunk_idx": 1, "raw_sha1": "c225b7b34939acb7e9aa59f8a98a59af049d59cb", "raw_chars": 1794, "clean_chars": 1785, "edit_ratio": 0.7664, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "The Communist Party on the one hand continued to represent the general public, the farmers, and the workers, as its basis. On the other hand, the Communist Party began to represent the rich people—the new business community in mainland China. So, on the one hand, the Communist Party continued to represent the poor, the workers, and the farmers, and on the other hand, it represented the rich. That is a big change in Communist Party theory and also in Chinese constitutional law. I think in Hong Kong it is the same. In your history, the business community was the enemy of the Communist Party, always against the rich. But now the Communist Party is the ruling party; the Communist Party must take into account all classes, the rich and the poor. So that is why, in implementing universal suffrage in Hong Kong, on the one hand, we must consider the interests of the general public, the ordinary middle class in Hong Kong, and the ordinary people in Hong Kong. That is no problem. That is why China permits Hong Kong to implement universal suffrage. But on the other hand, the business community is a reality. Even if it is a small group of people, a very small group of people, they control the destiny of the economy in Hong Kong. If we just ignore their interests, Hong Kong capitalism will stop. So that is why, on the one hand, we realize universal suffrage in Hong Kong, and on the other hand, we must guarantee the continued development of capitalism in Hong Kong. During an interview before his speech, Mr. Wang was asked about a controversial white paper on electoral issues released in June by the Hong Kong and Macau Affairs Office in Beijing. Mr. Wang was one of the experts whose suggestions were solicited, although he was not one of the authors of the final document.", "reject_reason": ""}
+{"doc_idx": 4393, "chunk_idx": 0, "raw_sha1": "7153242af1bf45b87ba0b69b92985e7cdb886abf", "raw_chars": 1900, "clean_chars": 1898, "edit_ratio": 0.0016, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "by the National People’s Congress Standing Committee on the broad outlines of policy changes envisioned for the 2017 election of the next chief executive of Hong Kong.\n\nIn his speech, he said giving people in Hong Kong an unfettered choice in who they could vote for would impinge on the interests of the city’s richest residents, who, he said, “control the destiny of the economy in Hong Kong.” Here is an excerpt from Mr. Wang’s prepared remarks, which he delivered in English: Democracy is a political matter, it is also an economic matter.\n\nA political system by its nature reflects and embodies the economic structure of said particular place.\n\nUniversal suffrage means the redistribution of economic interests among society’s members.\n\nWe have to take care of every class.\n\nEvery group of people.\n\nEvery person.\n\nRich or poor.\n\nNo one should be ignored.\n\nNo one should be left behind.\n\nEspecially those whose slice of pie will be shared by others upon the implementation of universal suffrage.\n\n[He added that he was referring to the business community’s share of the economy.] Their slice of pie will be shared by others through universal suffrage.\n\nSo we have to take full consideration of their concerns.\n\nThat’s why we require balanced participation.\n\nWe require nominating committees and functional constituencies.\n\nLater, in a question and answer session, Mr. Wang explained how this fit in with Communist Party theory.\n\nHe referred to the so-called Three Represents promoted during the term of President Jiang Zemin, which allowed capitalists to enter the Communist Party, which previously had been focused on peasants and workers: As you know the Communist Party initially, originally, only represents the people, not representing the billionaires, the businesspeople, in history.\n\nHowever, in 2002, the Communist Party changed its charter and later on China changed its Constitution.", "reject_reason": ""}
+{"doc_idx": 2840, "chunk_idx": 1, "raw_sha1": "0076f511733d94e7f5a54a378c64b651d2e43342", "raw_chars": 1949, "clean_chars": 1943, "edit_ratio": 0.0098, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Flames would start shooting from behind the center field fence, and from the smoke and mists, Jose Canseco would emerge, bat in hand, dressed in full uniform.\n\nThe winner of Round Two, now a twitching mass of pure despair and regret, would matchup with Canseco, head-to-head, under the basic rules of the first round.\n\nFirst to five homers wins, but this time against a pitching machine.\n\nIf the winner of Round Two needs to be wheeled or carried into the box, that would be allowed.\n\nStanding would not be required.\n\nCanseco would win, of course.\n\nThe entire thing would be a sham, rigged for this purpose.\n\nWhat’s the point of the Home Run Derby?\n\nIt’s an abstraction of real baseball, a perversion of what the sport is all about.\n\nIn this, it becomes theater, it becomes something with a meaning and a purpose, something people can enjoy.\n\nSomething that makes you feel.\n\nAward presentation: With Canseco victorious, Commissioner Manfred would carry a beautiful red rose to home plate and ask the crowd to be quiet for the award presentation.\n\nWith the raucous crowd now murmuring in anticipation, Manfred would speak.\n\n\"We would like to announce that Jose Canseco will now be allowed in the Hall of Fame...\"\n\nThe crowd would hiss, boo, and cheer, all at once.\n\n\"...so long as he returns to Major League Baseball and has about three or four more excellent seasons, because these numbers aren’t quite good enough, as is.\"\n\nThe crowd would go crazy again, jeering Canseco, who would realize that he was used, the butt of a very elaborate joke.\n\nManfred would laaaaaugh and laaaaaaaaugh.\n\nCanseco would look around desperately, pleading his case.\n\nThe winner of Round Two would still be rolling around somewhere, moaning uncomfortably.\n\nAnd the chants of \"SHAME. SHAME. SHAME. SHAME\" would start up again.\n\nA couple days later, they would let Barry Bonds in the Hall of Fame because, c’mon, you jerks, just let Barry Bonds in the Hall of Fame.", "reject_reason": ""}
+{"doc_idx": 4393, "chunk_idx": 2, "raw_sha1": "cf43489d7fa229150089389a960df1bd671c14d5", "raw_chars": 1093, "clean_chars": 1089, "edit_ratio": 0.0037, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Democracy advocates in Hong Kong have heavily criticized the white paper, contending that many of its passages represent a significant erosion in the high degree of autonomy that Beijing promised Hong Kong prior to its return by Britain to Chinese sovereignty in 1997.\n\nSome of the heaviest criticism has been directed at suggestions that judges need to be “patriotic” and should help in the administration of Hong Kong.\n\nThese passages raised concerns that the rule of law might be undermined, and that judges would rule for whichever side in a dispute had better ties to the Communist Party.\n\nMr. Wang was asked whether judges in Hong Kong should indeed be “patriotic,” keeping in mind that because judges in the United States did not see themselves as patriotic, but rather as upholding the Constitution, they helped stop the excesses of McCarthyism.\n\nHe replied: Yes, judges should be patriotic automatically.\n\nIt’s a natural requirement.\n\nEven if it may not be written in the law, in many countries, I think it’s a common practice.\n\nBut judicial patriotism does not mean the judiciary", "reject_reason": ""}
+{"doc_idx": 4831, "chunk_idx": 2, "raw_sha1": "3216e8822f97aa31f388a145eb246ed1ff67cae3", "raw_chars": 535, "clean_chars": 531, "edit_ratio": 0.0094, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Trump voters have been called foolish, disgusting, frustrated, misguided, crazy, stupid, idiotic, dummies, willfully ignorant, defying common sense, driven by emotion, alienated, irrational and unthinking, an incompetent mob, thugs, hideous, hateful, xenophobic, violent, fanatics, Nazis, and on and on.\n\nAnother writer, in an apparent effort to appear even-handed, wrote, \"Trump supporters are not stupid; they just haven't been taught how to think.\" Others have gone to the extremes of telling Trump supporters they are all going", "reject_reason": ""}
+{"doc_idx": 4831, "chunk_idx": 1, "raw_sha1": "a000036b795b37b85c0366fc0f3f9765cf60f415", "raw_chars": 1904, "clean_chars": 1903, "edit_ratio": 0.0034, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Since early March, Trump voters have endured some of the most insulting and malicious attacks ever in the print, online, and social media, except this time the charge is not being led by the left-wing media or the Democrats, but by other Republicans.\n\nThe attackers have been supporters of the #NeverTrump movement and of the remaining Republican challengers, most notably supporters of Senator Ted Cruz.\n\nTogether, they have waged a remarkably large and fairly effective smear campaign against Trump voters.\n\nAnd even though the worst may be over, especially now that Senator Cruz has suspended his campaign, it has not stopped yet.\n\nThe targets are primarily blue-collar whites, both Republican and Democrat, from small towns and rural areas of the country, who support Trump.\n\nMany of these people are factory workers, laborers, tradespeople, farmers, and small business owners.\n\nSome have college educations, but many who don't have high school diplomas.\n\nSome are unemployed.\n\nThese are the folks who used to be called the common people of America, the salt-of-the-Earth types, the ones who were depicted in the Norman Rockwell paintings.\n\nUnlike other established voting blocs and special interest groups, these people have no protectors in the media, beyond the established right-wing websites and talk radio, who, for their own reasons, have mostly abandoned them.\n\nSince blue-collar workers form the largest bloc of Trump supporters, they usually get slammed the hardest.\n\nThe simple fact that blue-collar workers, on average, have smaller incomes than white-collar workers invariably gets translated into economically disadvantaged, distressed, or poor.\n\nSince they are generally less well educated than people in the professions, they often get described as not well educated, poorly educated, or uneducated.\n\nIf it were nothing more than that, it would be bad enough, but it gets much worse.", "reject_reason": ""}
+{"doc_idx": 4831, "chunk_idx": 0, "raw_sha1": "02eb20c1e8e083aed722fe188f192e4e7dc6d9e8", "raw_chars": 1906, "clean_chars": 1906, "edit_ratio": 0.0, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "k in the movie, All the King’s Men (based on the eponymous Pulitzer Prize-winning novel by Robert Penn Warren) is apropos the treatment of the supporters of Donald Trump by the reigning tastemakers of the conservative movement.\n\nAn updated version could be: Listen up Trump supporters!\n\nYou are all hicks!\n\nYeah, you heard me right.\n\nYou are all hicks and worse!\n\nYou are hicks because you want decent good paying jobs, and you are sick of American companies moving overseas.\n\nYou are hicks because you want a wall on the border and illegal immigration stopped.\n\nYou are all hicks because you like your doctor and you want to keep your doctor.\n\nYou are hicks because you want your kids to learn something in school besides which bathroom to use and why they should hate America.\n\nYou are hicks because you think military veterans are less likely to die in combat than they are standing in line at the VA.\n\nYou are hicks because you think the Bill of Rights actually means something.\n\nTruth is you hicks are in the way.\n\nYou are nothing but speed bumps on the road to socialism.\n\nYou are nothing but an inconvenience to the politicians who want lifetime employment offering their services to the highest bidders.\n\nYou are nothing but a campaign problem to the billionaires who want to fatten their wallets at your expense.\n\nWhy don’t you keep in your place and do what you are told?\n\nWho do you think runs this country?\n\nHow dare you threaten the powers that be?\n\nYeah, that’s right.\n\nYou are a problem.\n\nYou are a hick.\n\nYou are all hicks!\n\nAnd so am I.\n\nIt was not long ago we knew who our enemies were.\n\nThe leftist Democrats called us racists, narrow-minded bigots, mean-spirited bible-thumpers, homophobes, rich fat-cats who want to take your social security away, sexists, and more.\n\nIt was insulting, and for the large majority, untrue, but it was predictable.\n\nThat is definitely not the case today.", "reject_reason": ""}
+{"doc_idx": 7195, "chunk_idx": 2, "raw_sha1": "d917ef497b0abbcaf21d5f31ed7a6edbf7b18a70", "raw_chars": 572, "clean_chars": 558, "edit_ratio": 0.7593, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "History says not really, but this year's Hawks could provide some precedent. He is one of the richest men in America, in the world for that matter, and if the Republicans get their way, Warren Buffett would be the perfect example of the rich in America who will directly benefit from their no-tax policies. But Mr. Buffett is operating in the realm of reality, and he knows that what the Republicans are trying to do – balance the budget on the backs of the poor – is simply not possible. Warren Buffett is speaking out, saying that the Republicans are \"play", "reject_reason": ""}
+{"doc_idx": 7195, "chunk_idx": 0, "raw_sha1": "f57fafb98983fcdf0687ff90014a6dc8a0235ba1", "raw_chars": 1892, "clean_chars": 1887, "edit_ratio": 0.005, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "something we'd like to change.\n\nWe invite the rest of the political media to follow our lead and reject tired anti-Hillary narratives.\n\nStop rewarding conservative Clinton-bashers who constructed a toxic framework for Hillary coverage decades ago that remains operative to this day.\n\nWe know all media companies go through cycles, and we will face our own ups and downs, but let our current success be a model for how to cover Hillary and Donald in the coming five months.\n\n[Melissa McEwan contributed to this article.]\n\nAs the Miami Heat stumble forward toward the NBA playoffs, there has been some chatter as to what a playoff berth and early elimination is actually worth.\n\nEven if Miami makes it beyond the first 82 games, it's unlikely they would beat either the Atlanta Hawks or the Cleveland Cavaliers and make it beyond the first round.\n\nIn fact, no eight seed with a losing record has ever won its opening series, according to data published by the Boston Globe.\n\nSo, assuming the Heat make the playoffs (for the purpose of this post) and lose in the first round (as history tells us they will), what benefit does such an experience have for Miami's players?\n\nWell as an eighth seed, not so much.\n\nAccording to the same piece by the Boston Globe, after making the playoffs as a No. 8 seed with a losing record, 60.9 percent of teams miss the playoffs the next season, 8.7 percent of teams are eliminated in the first round and 26.1 percent of teams are eliminated in the second round.\n\nOnly one team has advanced to the NBA Finals and none have won a championship in the year immediately following.\n\nSince the difference between the seventh and eighth seed in the East is just half a game, I went ahead and pulled the data for No. 7 seeds as well.\n\nJust as only five eight seeds in NBA history have advanced beyond the first round of the playoffs, so have only five seven seeds.", "reject_reason": ""}
+{"doc_idx": 7195, "chunk_idx": 1, "raw_sha1": "549c80dc07e8a57327914fb58103b4b8be022b08", "raw_chars": 1982, "clean_chars": 1982, "edit_ratio": 0.0202, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "Of those with losing records, only one team has ever won its first-round series (the 1986-87 Seattle Supersonics, who went to the Western Conference Finals).\n\nAs for how teams fare the year after making the playoffs as a seventh seed: [table id=13 /] There doesn't appear to be a correlation between making or missing the playoffs a year after being one of the bottom seeds, as 40 percent of teams that made the playoffs as a seventh seed missed the post-season the year after.\n\nTeams that made the playoffs as a seventh seed one year—regardless of record—have a 60 percent chance of making the playoffs the year after.\n\nWith a pretty even 60-40 split, that playoff experience doesn't seem to hold much weight when it comes to getting back to the post-season.\n\nHowever, once in the playoffs, nine of the 24 teams (37.5 percent) advanced to the next round.\n\nOnly one team with a losing record the year prior advanced beyond the first round—the 1984-85 Denver Nuggets, who advanced to the Western Conference Finals.\n\nTwo teams have made the NBA Finals a year after earning the seventh seed, but neither of them were No. 7 seeds with losing records.\n\nNo seventh seed has gone on to win a title the year after.\n\nIt's worth adding that three teams have won the championship after missing the playoffs altogether the season before (the 2007-08 Celtics, 1991-92 Rockets, and 1996-97 Spurs).\n\nHowever, a more comparable team for next season's Heat could be this season's Hawks.\n\nAtlanta made the playoffs as a No. 8 seed with a losing record last season and will be the top seed this season.\n\nLike this Heat team, the Hawks dealt with crippling injuries that stumped their season, with Al Horford playing just 29 games.\n\nChris Bosh, Dwyane Wade, Goran Dragic, and Hassan Whiteside are expected to start next season healthy.\n\nIt stands to reason the Heat will be better, but to what degree is the question.\n\nWill the playoff experience this team is gunning for make a difference next season?", "reject_reason": ""}
+{"doc_idx": 8417, "chunk_idx": 2, "raw_sha1": "f5bc1c9142ca9cb89deecae1df06bdcad214b06b", "raw_chars": 873, "clean_chars": 865, "edit_ratio": 0.0092, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "We now know there has been a deliberate cover-up,” Wong said. “The prime minister’s office, the attorney general and the foreign minister’s office were aware for a full parliamentary week that Ms Bishop and the Attorney-General’s Department had misled the parliament and chose to do nothing. “Wilfully misleading the parliament is a serious offence – the prime minister must explain the actions of his ministers and staff.” Abbott’s spokesman defended the government’s handling of the issue. “As soon as it became clear that there was a possible problem with the testimony of the officer from the Attorney General’s Department, a thorough review was undertaken by that department,” he said. “As soon as that review was completed, the record was corrected by the attorney general and by the foreign minister.” Abbott’s spokesman pointed to comments by the Asio chief", "reject_reason": ""}
+{"doc_idx": 8417, "chunk_idx": 0, "raw_sha1": "9bf789b4047dccef00dc72f7a89288f138388741", "raw_chars": 1891, "clean_chars": 1898, "edit_ratio": 0.0668, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "The error was corrected three days before the parliamentary record, on 4 June.\n\nLabor has been highly critical of the government for waiting until the final day of a parliamentary sitting fortnight to retract the previous claims, arguing that the new documents are evidence of \"a deliberate cover-up\".\n\nThe issue relates to a letter the siege gunman wrote to the attorney general, George Brandis, in October, two months before the deadly attack in the Lindt cafe, asking whether it was legal to contact the leader of Islamic State.\n\nBrandis and the foreign affairs minister, Julie Bishop, said on 28 May that Monis's letter had been given to the joint review conducted by the federal and New South Wales governments, which was completed in January.\n\nThey were relying on comments made a day earlier by Katherine Jones, the deputy secretary of the Attorney General's Department.\n\nThe documents, provided by the Attorney General's Department to a Senate committee, provide an insight into the talks that occurred between departments and ministerial offices before the formal correction was made on 4 June.\n\nOn Monday, 1 June, the Department of the Prime Minister and Cabinet provided a briefing note to the Attorney General's Department (AGD) that asserted: \"AGD never provided the Monis/Brandis letter to the Martin Place review team. The team was never aware of the existence of the letter.\" In an accompanying email at 12:15 pm, the deputy secretary of the Department of Prime Minister and Cabinet, Allan McKinnon, mentioned the Prime Minister's Office: \"PMO says that AG can answer any questions on this issue now that they know the review team didn't receive it.\" The Attorney General's Department asked the attorney general's office at 12:39 pm the same day \"whether any updates are required\" to the question time brief about the Monis correspondence \"in light of any discussions this morning\".", "reject_reason": ""}
+{"doc_idx": 8417, "chunk_idx": 1, "raw_sha1": "cf90f17cbf70c010db3e7b67cc10818a770e6797", "raw_chars": 1950, "clean_chars": 1948, "edit_ratio": 0.0662, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "The department was told: \"Update not necessary, we're just leaving it how it is.\" The following day, Tuesday, 2 June, the Attorney General's Department distributed an updated question time brief.\n\nQuestion time briefs are prepared for ministers to draw upon in answering questions in parliament.\n\n\"The document has been amended to reflect – but not highlight – that not ALL documents held by AGD were provided to the siege review. Happy to discuss,\" the department said in the email to Brandis's office on 2 June.\n\nBrandis has previously defended the delay in correcting the record.\n\nHe said he was advised on 1 June \"that it appeared\" that the department's advice about the correspondence was wrong, prompting him to ask his top bureaucrat, Chris Moraitis, to \"establish the facts\".\n\nBrandis's office received Moraitis's report by email at 1.09pm on 4 June.\n\nBrandis and Bishop corrected the record later that afternoon.\n\nIn the report, Moraitis said the Attorney General's Department had handed documents to the siege review in January.\n\nHe revealed that \"officers in the department\" had become aware on 2 February that Monis's letter and the department's reply \"had been inadvertently omitted from the correspondence provided to the review\".\n\n\"The officers became aware of this omission following the Australian federal police notifying the department that it had come into possession of the letter and the reply while making inquiries,\" Moraitis wrote.\n\nHe said a departmental officer contacted an officer in the review team at the Department of the Prime Minister and Cabinet on 2 February to advise them of the omission.\n\n\"The review team member advised that the text of the review had already been finalised and the department therefore did not provide the two documents,\" Moraitis said.\n\nLabor's Senate leader, Penny Wong, said the new evidence was damning.\n\n\"We already knew that government ministers had misled the Australian parliament.\"", "reject_reason": ""}
+{"doc_idx": 6276, "chunk_idx": 0, "raw_sha1": "ecdbc8441e0271ccf0e3932a2176ed14ae6d4ab5", "raw_chars": 1792, "clean_chars": 1781, "edit_ratio": 0.0087, "needs_rewrite": true, "decision": "keep", "reason": "rewritten", "edit_level": "rewrite", "domain": "", "prose_score": null, "junk_score": null, "removed_spans": [], "text": "and defining prohibited political activity to include all \"activity directed toward the success or failure of a political party, candidate for partisan political office, or partisan political group.\" Did Director Comey's letter to Congress violate the Hatch Act?\n\nThe Hatch Act provision most commonly invoked in discussions of Comey's letter is 5 U.S.C. § 7323(a)(1), which prohibits a government employee from \"us[ing] his official authority or influence for the purpose of interfering with or affecting the result of an election.\" The key text is the emphasized phrase -- which conditions a violation of the statute on whether the employee's purpose was to interfere with or affect the result of an election.\n\nThus, the Hatch Act does not focus on the effect of the employee's conduct, but the intent.\n\nTo that end, if Comey did not intend to interfere with or affect the upcoming election through his letter to Congress, then he did not violate the letter of the Hatch Act.\n\nOf course, only Comey knows what his intent was.\n\nBut Richard W. Painter, the chief White House ethics lawyer from 2005-07 (during the George W. Bush Administration), argued in a New York Times op-ed on Sunday that Comey's intent can be inferred from the absence of a good reason for sending the letter.\n\n\"Absent extraordinary circumstances that might justify it, a public communication about a pending F.B.I. investigation involving a candidate that is made on the eve of an election is . . . very likely to be a violation of the Hatch Act and a misuse of an official position,\" Painter wrote.\n\nAnd Senate Minority Leader Harry Reid invoked the Hatch Act in a letter to Sunday night.\n\n\"I am writing to inform you that my office has determined that these actions may violate the Hatch Act,\" Reid wrote.", "reject_reason": ""}