two version of R2R are here HEAD master

5 files changed, 489 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/colorlog/__init__.py b/.venv/lib/python3.12/site-packages/colorlog/__init__.py
new file mode 100644
index 00000000..fb123b8b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/colorlog/__init__.py
@@ -0,0 +1,66 @@
+"""A logging formatter for colored output."""
+
+import sys
+import warnings
+
+from colorlog.formatter import (
+    ColoredFormatter,
+    LevelFormatter,
+    TTYColoredFormatter,
+    default_log_colors,
+)
+from colorlog.wrappers import (
+    CRITICAL,
+    DEBUG,
+    ERROR,
+    FATAL,
+    INFO,
+    NOTSET,
+    StreamHandler,
+    WARN,
+    WARNING,
+    basicConfig,
+    critical,
+    debug,
+    error,
+    exception,
+    getLogger,
+    info,
+    log,
+    root,
+    warning,
+)
+
+__all__ = (
+    "CRITICAL",
+    "DEBUG",
+    "ERROR",
+    "FATAL",
+    "INFO",
+    "NOTSET",
+    "WARN",
+    "WARNING",
+    "ColoredFormatter",
+    "LevelFormatter",
+    "StreamHandler",
+    "TTYColoredFormatter",
+    "basicConfig",
+    "critical",
+    "debug",
+    "default_log_colors",
+    "error",
+    "exception",
+    "exception",
+    "getLogger",
+    "info",
+    "log",
+    "root",
+    "warning",
+)
+
+if sys.version_info < (3, 6):
+    warnings.warn(
+        "Colorlog requires Python 3.6 or above. Pin 'colorlog<5' to your dependencies "
+        "if you require compatibility with older versions of Python. See "
+        "https://github.com/borntyping/python-colorlog#status for more information."
+    )
diff --git a/.venv/lib/python3.12/site-packages/colorlog/escape_codes.py b/.venv/lib/python3.12/site-packages/colorlog/escape_codes.py
new file mode 100644
index 00000000..185b9473
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/colorlog/escape_codes.py
@@ -0,0 +1,105 @@
+"""
+Generates a dictionary of ANSI escape codes.
+
+http://en.wikipedia.org/wiki/ANSI_escape_code
+
+Uses colorama as an optional dependency to support color on Windows
+"""
+
+import sys
+
+try:
+    import colorama
+except ImportError:
+    pass
+else:
+    if sys.platform == "win32":
+        colorama.init(strip=False)
+
+__all__ = ("escape_codes", "parse_colors")
+
+
+# Returns escape codes from format codes
+def esc(*codes: int) -> str:
+    return "\033[" + ";".join(str(code) for code in codes) + "m"
+
+
+escape_codes = {
+    "reset": esc(0),
+    "bold": esc(1),
+    "thin": esc(2),
+}
+
+escape_codes_foreground = {
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "purple": 35,
+    "cyan": 36,
+    "white": 37,
+    "light_black": 90,
+    "light_red": 91,
+    "light_green": 92,
+    "light_yellow": 93,
+    "light_blue": 94,
+    "light_purple": 95,
+    "light_cyan": 96,
+    "light_white": 97,
+}
+
+escape_codes_background = {
+    "black": 40,
+    "red": 41,
+    "green": 42,
+    "yellow": 43,
+    "blue": 44,
+    "purple": 45,
+    "cyan": 46,
+    "white": 47,
+    "light_black": 100,
+    "light_red": 101,
+    "light_green": 102,
+    "light_yellow": 103,
+    "light_blue": 104,
+    "light_purple": 105,
+    "light_cyan": 106,
+    "light_white": 107,
+    # Bold background colors don't exist,
+    # but we used to provide these names.
+    "bold_black": 100,
+    "bold_red": 101,
+    "bold_green": 102,
+    "bold_yellow": 103,
+    "bold_blue": 104,
+    "bold_purple": 105,
+    "bold_cyan": 106,
+    "bold_white": 107,
+}
+
+# Foreground without prefix
+for name, code in escape_codes_foreground.items():
+    escape_codes["%s" % name] = esc(code)
+    escape_codes["bold_%s" % name] = esc(1, code)
+    escape_codes["thin_%s" % name] = esc(2, code)
+
+# Foreground with fg_ prefix
+for name, code in escape_codes_foreground.items():
+    escape_codes["fg_%s" % name] = esc(code)
+    escape_codes["fg_bold_%s" % name] = esc(1, code)
+    escape_codes["fg_thin_%s" % name] = esc(2, code)
+
+# Background with bg_ prefix
+for name, code in escape_codes_background.items():
+    escape_codes["bg_%s" % name] = esc(code)
+
+# 256 colour support
+for code in range(256):
+    escape_codes["fg_%d" % code] = esc(38, 5, code)
+    escape_codes["bg_%d" % code] = esc(48, 5, code)
+
+
+def parse_colors(string: str) -> str:
+    """Return escape codes from a color sequence string."""
+    return "".join(escape_codes[n] for n in string.split(",") if n)
diff --git a/.venv/lib/python3.12/site-packages/colorlog/formatter.py b/.venv/lib/python3.12/site-packages/colorlog/formatter.py
new file mode 100644
index 00000000..f011ca29
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/colorlog/formatter.py
@@ -0,0 +1,217 @@
+"""The ColoredFormatter class."""
+
+import logging
+import os
+import sys
+import typing
+
+import colorlog.escape_codes
+
+__all__ = (
+    "default_log_colors",
+    "ColoredFormatter",
+    "LevelFormatter",
+    "TTYColoredFormatter",
+)
+
+# Type aliases used in function signatures.
+EscapeCodes = typing.Mapping[str, str]
+LogColors = typing.Mapping[str, str]
+SecondaryLogColors = typing.Mapping[str, LogColors]
+if sys.version_info >= (3, 8):
+    _FormatStyle = typing.Literal["%", "{", "$"]
+else:
+    _FormatStyle = str
+
+# The default colors to use for the debug levels
+default_log_colors = {
+    "DEBUG": "white",
+    "INFO": "green",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "bold_red",
+}
+
+# The default format to use for each style
+default_formats = {
+    "%": "%(log_color)s%(levelname)s:%(name)s:%(message)s",
+    "{": "{log_color}{levelname}:{name}:{message}",
+    "$": "${log_color}${levelname}:${name}:${message}",
+}
+
+
+class ColoredRecord:
+    """
+    Wraps a LogRecord, adding escape codes to the internal dict.
+
+    The internal dict is used when formatting the message (by the PercentStyle,
+    StrFormatStyle, and StringTemplateStyle classes).
+    """
+
+    def __init__(self, record: logging.LogRecord, escapes: EscapeCodes) -> None:
+        self.__dict__.update(record.__dict__)
+        self.__dict__.update(escapes)
+
+
+class ColoredFormatter(logging.Formatter):
+    """
+    A formatter that allows colors to be placed in the format string.
+
+    Intended to help in creating more readable logging output.
+    """
+
+    def __init__(
+        self,
+        fmt: typing.Optional[str] = None,
+        datefmt: typing.Optional[str] = None,
+        style: _FormatStyle = "%",
+        log_colors: typing.Optional[LogColors] = None,
+        reset: bool = True,
+        secondary_log_colors: typing.Optional[SecondaryLogColors] = None,
+        validate: bool = True,
+        stream: typing.Optional[typing.IO] = None,
+        no_color: bool = False,
+        force_color: bool = False,
+        defaults: typing.Optional[typing.Mapping[str, typing.Any]] = None,
+    ) -> None:
+        """
+        Set the format and colors the ColoredFormatter will use.
+
+        The ``fmt``, ``datefmt``, ``style``, and ``default`` args are passed on to the
+        ``logging.Formatter`` constructor.
+
+        The ``secondary_log_colors`` argument can be used to create additional
+        ``log_color`` attributes. Each key in the dictionary will set
+        ``{key}_log_color``, using the value to select from a different
+        ``log_colors`` set.
+
+        :Parameters:
+        - fmt (str): The format string to use.
+        - datefmt (str): A format string for the date.
+        - log_colors (dict):
+            A mapping of log level names to color names.
+        - reset (bool):
+            Implicitly append a color reset to all records unless False.
+        - style ('%' or '{' or '$'):
+            The format style to use.
+        - secondary_log_colors (dict):
+            Map secondary ``log_color`` attributes. (*New in version 2.6.*)
+        - validate (bool)
+            Validate the format string.
+        - stream (typing.IO)
+            The stream formatted messages will be printed to. Used to toggle colour
+            on non-TTY outputs. Optional.
+        - no_color (bool):
+            Disable color output.
+        - force_color (bool):
+            Enable color output. Takes precedence over `no_color`.
+        """
+
+        # Select a default format if `fmt` is not provided.
+        fmt = default_formats[style] if fmt is None else fmt
+
+        if sys.version_info >= (3, 10):
+            super().__init__(fmt, datefmt, style, validate, defaults=defaults)
+        elif sys.version_info >= (3, 8):
+            super().__init__(fmt, datefmt, style, validate)
+        else:
+            super().__init__(fmt, datefmt, style)
+
+        self.log_colors = log_colors if log_colors is not None else default_log_colors
+        self.secondary_log_colors = (
+            secondary_log_colors if secondary_log_colors is not None else {}
+        )
+        self.reset = reset
+        self.stream = stream
+        self.no_color = no_color
+        self.force_color = force_color
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        """Format a message from a record object."""
+        escapes = self._escape_code_map(record.levelname)
+        wrapper = ColoredRecord(record, escapes)
+        message = super().formatMessage(wrapper)  # type: ignore
+        message = self._append_reset(message, escapes)
+        return message
+
+    def _escape_code_map(self, item: str) -> EscapeCodes:
+        """
+        Build a map of keys to escape codes for use in message formatting.
+
+        If _blank_escape_codes() returns True, all values will be an empty string.
+        """
+        codes = {**colorlog.escape_codes.escape_codes}
+        codes.setdefault("log_color", self._get_escape_code(self.log_colors, item))
+        for name, colors in self.secondary_log_colors.items():
+            codes.setdefault("%s_log_color" % name, self._get_escape_code(colors, item))
+        if self._blank_escape_codes():
+            codes = {key: "" for key in codes.keys()}
+        return codes
+
+    def _blank_escape_codes(self):
+        """Return True if we should be prevented from printing escape codes."""
+        if self.force_color or "FORCE_COLOR" in os.environ:
+            return False
+
+        if self.no_color or "NO_COLOR" in os.environ:
+            return True
+
+        if self.stream is not None and not self.stream.isatty():
+            return True
+
+        return False
+
+    @staticmethod
+    def _get_escape_code(log_colors: LogColors, item: str) -> str:
+        """Extract a color sequence from a mapping, and return escape codes."""
+        return colorlog.escape_codes.parse_colors(log_colors.get(item, ""))
+
+    def _append_reset(self, message: str, escapes: EscapeCodes) -> str:
+        """Add a reset code to the end of the message, if it's not already there."""
+        reset_escape_code = escapes["reset"]
+
+        if self.reset and not message.endswith(reset_escape_code):
+            message += reset_escape_code
+
+        return message
+
+
+class LevelFormatter:
+    """An extension of ColoredFormatter that uses per-level format strings."""
+
+    def __init__(self, fmt: typing.Mapping[str, str], **kwargs: typing.Any) -> None:
+        """
+        Configure a ColoredFormatter with its own format string for each log level.
+
+        Supports fmt as a dict. All other args are passed on to the
+        ``colorlog.ColoredFormatter`` constructor.
+
+        :Parameters:
+        - fmt (dict):
+            A mapping of log levels (represented as strings, e.g. 'WARNING') to
+            format strings. (*New in version 2.7.0)
+        (All other parameters are the same as in colorlog.ColoredFormatter)
+
+        Example:
+
+        formatter = colorlog.LevelFormatter(
+            fmt={
+                "DEBUG": "%(log_color)s%(message)s (%(module)s:%(lineno)d)",
+                "INFO": "%(log_color)s%(message)s",
+                "WARNING": "%(log_color)sWRN: %(message)s (%(module)s:%(lineno)d)",
+                "ERROR": "%(log_color)sERR: %(message)s (%(module)s:%(lineno)d)",
+                "CRITICAL": "%(log_color)sCRT: %(message)s (%(module)s:%(lineno)d)",
+            }
+        )
+        """
+        self.formatters = {
+            level: ColoredFormatter(fmt=f, **kwargs) for level, f in fmt.items()
+        }
+
+    def format(self, record: logging.LogRecord) -> str:
+        return self.formatters[record.levelname].format(record)
+
+
+# Provided for backwards compatibility. The features provided by this subclass are now
+# included directly in the `ColoredFormatter` class.
+TTYColoredFormatter = ColoredFormatter
diff --git a/.venv/lib/python3.12/site-packages/colorlog/py.typed b/.venv/lib/python3.12/site-packages/colorlog/py.typed
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/colorlog/py.typed
diff --git a/.venv/lib/python3.12/site-packages/colorlog/wrappers.py b/.venv/lib/python3.12/site-packages/colorlog/wrappers.py
new file mode 100644
index 00000000..e05756fb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/colorlog/wrappers.py
@@ -0,0 +1,101 @@
+"""Wrappers around the logging module."""
+
+import functools
+import logging
+import sys
+import typing
+from logging import (
+    CRITICAL,
+    DEBUG,
+    ERROR,
+    FATAL,
+    INFO,
+    NOTSET,
+    StreamHandler,
+    WARN,
+    WARNING,
+    getLogger,
+    root,
+)
+
+import colorlog.formatter
+
+__all__ = (
+    "CRITICAL",
+    "DEBUG",
+    "ERROR",
+    "FATAL",
+    "INFO",
+    "NOTSET",
+    "WARN",
+    "WARNING",
+    "StreamHandler",
+    "basicConfig",
+    "critical",
+    "debug",
+    "error",
+    "exception",
+    "getLogger",
+    "info",
+    "log",
+    "root",
+    "warning",
+)
+
+
+def basicConfig(
+    style: colorlog.formatter._FormatStyle = "%",
+    log_colors: typing.Optional[colorlog.formatter.LogColors] = None,
+    reset: bool = True,
+    secondary_log_colors: typing.Optional[colorlog.formatter.SecondaryLogColors] = None,
+    format: str = "%(log_color)s%(levelname)s%(reset)s:%(name)s:%(message)s",
+    datefmt: typing.Optional[str] = None,
+    **kwargs
+) -> None:
+    """Call ``logging.basicConfig`` and override the formatter it creates."""
+    logging.basicConfig(**kwargs)
+
+    def _basicConfig():
+        handler = logging.root.handlers[0]
+        handler.setFormatter(
+            colorlog.formatter.ColoredFormatter(
+                fmt=format,
+                datefmt=datefmt,
+                style=style,
+                log_colors=log_colors,
+                reset=reset,
+                secondary_log_colors=secondary_log_colors,
+                stream=kwargs.get("stream", None),
+            )
+        )
+
+    if sys.version_info >= (3, 13):
+        with logging._lock:  # type: ignore
+            _basicConfig()
+    else:
+        logging._acquireLock()  # type: ignore
+        try:
+            _basicConfig()
+        finally:
+            logging._releaseLock()  # type: ignore
+
+
+def ensure_configured(func):
+    """Modify a function to call our basicConfig() first if no handlers exist."""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if len(logging.root.handlers) == 0:
+            basicConfig()
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+debug = ensure_configured(logging.debug)
+info = ensure_configured(logging.info)
+warning = ensure_configured(logging.warning)
+error = ensure_configured(logging.error)
+critical = ensure_configured(logging.critical)
+log = ensure_configured(logging.log)
+exception = ensure_configured(logging.exception)