Add files using upload-large-folder tool

.gitattributes

@@ -64,3 +64,4 @@ llmeval-env/lib/python3.10/site-packages/scipy/optimize/_highs/_highs_wrapper.cp
 llmeval-env/lib/python3.10/site-packages/scipy/sparse/_sparsetools.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/scipy/spatial/_ckdtree.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/scipy/spatial/_qhull.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+llmeval-env/lib/python3.10/site-packages/scipy/misc/face.dat filter=lfs diff=lfs merge=lfs -text

llmeval-env/lib/python3.10/site-packages/pytablewriter/_logger/__init__.py

@@ -0,0 +1,4 @@
+from ._logger import WriterLogger, logger, set_logger
+
+
+__all__ = ("WriterLogger", "logger", "set_logger")

llmeval-env/lib/python3.10/site-packages/pytablewriter/_logger/_logger.py

@@ -0,0 +1,117 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from typing import TYPE_CHECKING, List
+
+import dataproperty
+from mbstrdecoder import MultiByteStrDecoder
+
+from ._null_logger import NullLogger  # type: ignore
+
+
+if TYPE_CHECKING:
+    from ..writer import AbstractTableWriter
+
+MODULE_NAME = "pytablewriter"
+
+try:
+    from loguru import logger
+
+    logger.disable(MODULE_NAME)
+except ImportError:
+    logger = NullLogger()
+
+
+def set_logger(is_enable: bool, propagation_depth: int = 1) -> None:
+    if is_enable:
+        logger.enable(MODULE_NAME)
+    else:
+        logger.disable(MODULE_NAME)
+
+    if propagation_depth <= 0:
+        return
+
+    dataproperty.set_logger(is_enable, propagation_depth - 1)
+
+    try:
+        import simplesqlite
+
+        simplesqlite.set_logger(is_enable, propagation_depth - 1)
+    except ImportError:
+        pass
+
+    try:
+        import pytablereader
+
+        pytablereader.set_logger(is_enable, propagation_depth - 1)
+    except ImportError:
+        pass
+
+
+class WriterLogger:
+    @property
+    def logger(self):  # type: ignore
+        return self.__logger
+
+    def __init__(self, writer: "AbstractTableWriter") -> None:
+        self.__writer = writer
+        self.__logger = logger
+
+        self.logger.debug(f"created WriterLogger: format={writer.format_name}")
+
+    def __enter__(self) -> "WriterLogger":
+        self.logging_start_write()
+        return self
+
+    def __exit__(self, *exc):  # type: ignore
+        self.logging_complete_write()
+        return False
+
+    def logging_start_write(self) -> None:
+        log_entry_list = [
+            self.__get_format_name_message(),
+            self.__get_table_name_message(),
+            f"headers={self.__writer.headers}",
+        ]
+
+        try:
+            log_entry_list.append(f"rows={len(self.__writer.value_matrix)}")
+        except (TypeError, AttributeError):
+            log_entry_list.append("rows=NaN")
+
+        log_entry_list.append(self.__get_typehint_message())
+        log_entry_list.extend(self.__get_extra_log_entry_list())
+
+        self.logger.debug("start write table: {}".format(", ".join(log_entry_list)))
+
+    def logging_complete_write(self) -> None:
+        log_entry_list = [self.__get_format_name_message(), self.__get_table_name_message()]
+        log_entry_list.extend(self.__get_extra_log_entry_list())
+
+        self.logger.debug("complete write table: {}".format(", ".join(log_entry_list)))
+
+    def __get_format_name_message(self) -> str:
+        return f"format={self.__writer.format_name:s}"
+
+    def __get_table_name_message(self) -> str:
+        if self.__writer.table_name:
+            table_name = MultiByteStrDecoder(self.__writer.table_name).unicode_str
+        else:
+            table_name = ""
+
+        return f"table-name='{table_name}'"
+
+    def __get_extra_log_entry_list(self) -> List[str]:
+        if self.__writer._iter_count is None:
+            return []
+
+        return [f"iteration={self.__writer._iter_count}/{self.__writer.iteration_length}"]
+
+    def __get_typehint_message(self) -> str:
+        try:
+            return "type-hints={}".format(
+                [type_hint(None).typename for type_hint in self.__writer.type_hints]
+            )
+        except (TypeError, AttributeError):
+            return "type-hints=[]"

llmeval-env/lib/python3.10/site-packages/pytablewriter/_logger/_null_logger.py

@@ -0,0 +1,44 @@
+# type: ignore
+
+
+class NullLogger:
+    level_name = None
+
+    def remove(self, handler_id=None):  # pragma: no cover
+        pass
+
+    def add(self, sink, **kwargs):  # pragma: no cover
+        pass
+
+    def disable(self, name):  # pragma: no cover
+        pass
+
+    def enable(self, name):  # pragma: no cover
+        pass
+
+    def critical(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def debug(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def error(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def exception(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def info(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def log(self, __level, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def success(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def trace(self, __message, *args, **kwargs):  # pragma: no cover
+        pass
+
+    def warning(self, __message, *args, **kwargs):  # pragma: no cover
+        pass

llmeval-env/lib/python3.10/site-packages/pytablewriter/typehint/__init__.py

@@ -0,0 +1,38 @@
+from dataproperty.typing import TypeHint
+from typepy import (
+    Binary,
+    Bool,
+    Bytes,
+    DateTime,
+    Dictionary,
+    Infinity,
+    Integer,
+    IpAddress,
+    List,
+    Nan,
+    NoneType,
+    NullString,
+    RealNumber,
+    String,
+)
+from typepy.type import AbstractType
+
+
+__all__ = (
+    "Binary",
+    "Bool",
+    "Bytes",
+    "DateTime",
+    "Dictionary",
+    "Infinity",
+    "Integer",
+    "IpAddress",
+    "List",
+    "Nan",
+    "NoneType",
+    "NullString",
+    "RealNumber",
+    "String",
+    "TypeHint",
+    "AbstractType",
+)

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/__init__.py

@@ -0,0 +1,74 @@
+from ._elasticsearch import ElasticsearchWriter
+from ._null import NullTableWriter
+from ._table_writer import AbstractTableWriter
+from .binary import (
+    ExcelXlsTableWriter,
+    ExcelXlsxTableWriter,
+    PandasDataFramePickleWriter,
+    SqliteTableWriter,
+)
+from .text import (
+    AsciiDocTableWriter,
+    BoldUnicodeTableWriter,
+    BorderlessTableWriter,
+    CssTableWriter,
+    CsvTableWriter,
+    HtmlTableWriter,
+    JsonLinesTableWriter,
+    JsonTableWriter,
+    LatexMatrixWriter,
+    LatexTableWriter,
+    LtsvTableWriter,
+    MarkdownTableWriter,
+    MediaWikiTableWriter,
+    RstCsvTableWriter,
+    RstGridTableWriter,
+    RstSimpleTableWriter,
+    SpaceAlignedTableWriter,
+    TomlTableWriter,
+    TsvTableWriter,
+    UnicodeTableWriter,
+    YamlTableWriter,
+)
+from .text.sourcecode import (
+    JavaScriptTableWriter,
+    NumpyTableWriter,
+    PandasDataFrameWriter,
+    PythonCodeTableWriter,
+)
+
+
+__all__ = (
+    "AbstractTableWriter",
+    "AsciiDocTableWriter",
+    "BoldUnicodeTableWriter",
+    "BorderlessTableWriter",
+    "CssTableWriter",
+    "CsvTableWriter",
+    "ElasticsearchWriter",
+    "ExcelXlsTableWriter",
+    "ExcelXlsxTableWriter",
+    "HtmlTableWriter",
+    "JavaScriptTableWriter",
+    "JsonLinesTableWriter",
+    "JsonTableWriter",
+    "LatexMatrixWriter",
+    "LatexTableWriter",
+    "LtsvTableWriter",
+    "MarkdownTableWriter",
+    "MediaWikiTableWriter",
+    "NullTableWriter",
+    "NumpyTableWriter",
+    "PandasDataFramePickleWriter",
+    "PandasDataFrameWriter",
+    "PythonCodeTableWriter",
+    "RstCsvTableWriter",
+    "RstGridTableWriter",
+    "RstSimpleTableWriter",
+    "SpaceAlignedTableWriter",
+    "SqliteTableWriter",
+    "TomlTableWriter",
+    "TsvTableWriter",
+    "UnicodeTableWriter",
+    "YamlTableWriter",
+)

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/_common.py

@@ -0,0 +1,12 @@
+from textwrap import dedent
+
+
+HEADER_ROW = -1
+
+
+import_error_msg_template = dedent(
+    """\
+    dependency packages for {0} not found.
+    you can install the dependencies with 'pip install pytablewriter[{0}]'
+    """
+)

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/_elasticsearch.py

@@ -0,0 +1,204 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+
+import copy
+from typing import Any, Dict, Generator
+
+import dataproperty
+from dataproperty import ColumnDataProperty
+from typepy import Typecode
+
+from ..error import EmptyValueError
+from ._msgfy import to_error_message
+from ._table_writer import AbstractTableWriter
+
+
+DataType = Dict[str, str]
+Properties = Dict[str, DataType]
+
+
+def _get_es_datatype(column_dp: ColumnDataProperty) -> DataType:
+    if column_dp.typecode in (
+        Typecode.NONE,
+        Typecode.NULL_STRING,
+        Typecode.INFINITY,
+        Typecode.NAN,
+    ):
+        return {"type": "keyword"}
+
+    if column_dp.typecode == Typecode.STRING:
+        return {"type": "text"}
+
+    if column_dp.typecode == Typecode.DATETIME:
+        return {"type": "date", "format": "date_optional_time"}
+
+    if column_dp.typecode == Typecode.REAL_NUMBER:
+        return {"type": "double"}
+
+    if column_dp.typecode == Typecode.BOOL:
+        return {"type": "boolean"}
+
+    if column_dp.typecode == Typecode.IP_ADDRESS:
+        return {"type": "ip"}
+
+    if column_dp.typecode == Typecode.INTEGER:
+        assert column_dp.bit_length is not None
+
+        if column_dp.bit_length <= 8:
+            return {"type": "byte"}
+        elif column_dp.bit_length <= 16:
+            return {"type": "short"}
+        elif column_dp.bit_length <= 32:
+            return {"type": "integer"}
+        elif column_dp.bit_length <= 64:
+            return {"type": "long"}
+
+        raise ValueError(
+            f"too large integer bits: expected<=64bits, actual={column_dp.bit_length:d}bits"
+        )
+
+    raise ValueError(f"unknown typecode: {column_dp.typecode}")
+
+
+class ElasticsearchWriter(AbstractTableWriter):
+    """
+    A table writer class for Elasticsearch.
+
+    :Dependency Packages:
+        - `elasticsearch-py <https://github.com/elastic/elasticsearch-py>`__
+
+    .. py:attribute:: index_name
+        :type: str
+
+        Alias attribute for |table_name|.
+
+    .. py:attribute:: document_type
+        :type: str
+        :value: "table"
+
+        Specify document type for indices.
+
+    .. py:method:: write_table()
+
+        Create an index and put documents for each row to Elasticsearch.
+
+        You need to pass an
+        `elasticsearch.Elasticsearch <https://elasticsearch-py.rtfd.io/en/master/api.html#elasticsearch>`__
+        instance to |stream| before calling this method.
+        |table_name|/:py:attr:`~pytablewriter.ElasticsearchWriter.index_name`
+        used as the creating index name,
+        invalid characters in the name are replaced with underscores (``'_'``).
+        Document data types for documents are automatically detected from the data.
+
+        :raises ValueError:
+            If the |stream| has not elasticsearch.Elasticsearch instance.
+        :Example:
+            :ref:`example-elasticsearch-table-writer`
+    """
+
+    FORMAT_NAME = "elasticsearch"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return True
+
+    @property
+    def table_name(self) -> str:
+        return super().table_name
+
+    @table_name.setter
+    def table_name(self, value: str) -> None:
+        from pathvalidate import ErrorReason, ValidationError
+
+        from ..sanitizer import ElasticsearchIndexNameSanitizer
+
+        try:
+            self._table_name = ElasticsearchIndexNameSanitizer(value).sanitize(replacement_text="_")
+        except ValidationError as e:
+            if e.reason is ErrorReason.NULL_NAME:
+                self._table_name = ""
+            else:
+                raise
+
+    @property
+    def index_name(self) -> str:
+        return self.table_name
+
+    @index_name.setter
+    def index_name(self, value: str) -> None:
+        self.table_name = value
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.stream = None
+        self.is_padding = False
+        self.is_formatting_float = False
+        self._is_require_table_name = True
+        self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
+        self._dp_extractor.type_value_map = copy.deepcopy(dataproperty.DefaultValue.TYPE_VALUE_MAP)
+
+        self.document_type = "table"
+
+    def write_null_line(self) -> None:
+        pass
+
+    def _get_mappings(self) -> Dict[str, Dict[str, Dict[str, Properties]]]:
+        properties: Properties = {}
+
+        for header, column_dp in zip(self.headers, self._column_dp_list):
+            properties[header] = _get_es_datatype(column_dp)
+
+        return {"mappings": {self.document_type: {"properties": properties}}}
+
+    def _get_body(self) -> Generator:
+        str_datatype = (Typecode.DATETIME, Typecode.IP_ADDRESS, Typecode.INFINITY, Typecode.NAN)
+
+        for value_dp_list in self._table_value_dp_matrix:
+            values = [
+                value_dp.data if value_dp.typecode not in str_datatype else value_dp.to_str()
+                for value_dp in value_dp_list
+            ]
+
+            yield dict(zip(self.headers, values))
+
+    def _write_table(self, **kwargs: Any) -> None:
+        import elasticsearch as es
+
+        if not isinstance(self.stream, es.Elasticsearch):
+            raise ValueError("stream must be an elasticsearch.Elasticsearch instance")
+
+        try:
+            self._verify_value_matrix()
+        except EmptyValueError:
+            self._logger.logger.debug("no tabular data found")
+            return
+
+        self._preprocess()
+
+        mappings = self._get_mappings()
+
+        try:
+            result = self.stream.indices.create(index=self.index_name, body=mappings)
+            self._logger.logger.debug(result)
+        except es.TransportError as e:
+            if e.error == "index_already_exists_exception":
+                # ignore already existing index
+                self._logger.logger.debug(to_error_message(e))
+            else:
+                raise
+
+        for body in self._get_body():
+            try:
+                self.stream.index(index=self.index_name, body=body, doc_type=self.document_type)
+            except es.exceptions.RequestError as e:
+                self._logger.logger.error(f"{to_error_message(e)}, body={body}")
+
+    def _write_value_row_separator(self) -> None:
+        pass

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/_interface.py

@@ -0,0 +1,84 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import abc
+from typing import IO, Any, Union
+
+
+class TableWriterInterface(metaclass=abc.ABCMeta):
+    """
+    Interface class for writing a table.
+    """
+
+    @abc.abstractproperty
+    def format_name(self) -> str:  # pragma: no cover
+        """Format name for the writer.
+
+        Returns:
+            |str|
+        """
+
+    @abc.abstractproperty
+    def support_split_write(self) -> bool:  # pragma: no cover
+        """Indicates whether the writer class supports iterative table writing (``write_table_iter``) method.
+
+        Returns:
+            bool: |True| if the writer supported iterative table writing.
+        """
+
+    @abc.abstractmethod
+    def write_table(self, **kwargs: Any) -> None:  # pragma: no cover
+        """
+        |write_table|.
+        """
+
+    def dump(
+        self, output: Union[str, IO], close_after_write: bool, **kwargs: Any
+    ) -> None:  # pragma: no cover
+        raise NotImplementedError(f"{self.format_name} writer did not support dump method")
+
+    def dumps(self) -> str:  # pragma: no cover
+        raise NotImplementedError(f"{self.format_name} writer did not support dumps method")
+
+    def write_table_iter(self, **kwargs: Any) -> None:  # pragma: no cover
+        """
+        Write a table with iteration.
+        "Iteration" means that divide the table writing into multiple writes.
+        This method is helpful, especially for extensive data.
+        The following are the premises to execute this method:
+
+        - set iterator to the |value_matrix|
+        - set the number of iterations to the |iteration_length| attribute
+
+        Call back function (Optional):
+        A callback function is called when each iteration of writing a table is completed.
+        You can set a callback function via the |write_callback| attribute.
+
+        Raises:
+            pytablewriter.NotSupportedError: If the writer class does not support this method.
+
+        .. note::
+            The following classes do not support this method:
+
+                - |HtmlTableWriter|
+                - |RstGridTableWriter|
+                - |RstSimpleTableWriter|
+
+            ``support_split_write`` attribute return |True| if the class
+            is supporting this method.
+        """
+
+        self._write_table_iter(**kwargs)
+
+    @abc.abstractmethod
+    def _write_table_iter(self, **kwargs: Any) -> None:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def close(self) -> None:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def _write_value_row_separator(self) -> None:  # pragma: no cover
+        pass

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/_null.py

@@ -0,0 +1,61 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+from typing import IO, Any, Union
+
+from ._interface import TableWriterInterface
+from .text._interface import IndentationInterface, TextWriterInterface
+
+
+class NullTableWriter(IndentationInterface, TextWriterInterface, TableWriterInterface):
+    FORMAT_NAME = "null"
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.table_name = kwargs.get("table_name", "")
+        self.value_matrix = kwargs.get("value_matrix", [])
+        self.is_formatting_float = kwargs.get("is_formatting_float", True)
+        self.headers = kwargs.get("headers", [])
+        self.type_hints = kwargs.get("type_hints", [])
+        self.max_workers = kwargs.get("max_workers", 1)
+
+    def __repr__(self) -> str:
+        return self.dumps()
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return True
+
+    def set_indent_level(self, indent_level: int) -> None:
+        pass
+
+    def inc_indent_level(self) -> None:
+        pass
+
+    def dec_indent_level(self) -> None:
+        pass
+
+    def write_null_line(self) -> None:
+        pass
+
+    def write_table(self, **kwargs: Any) -> None:
+        pass
+
+    def dump(self, output: Union[str, IO], close_after_write: bool = True, **kwargs: Any) -> None:
+        pass
+
+    def dumps(self) -> str:
+        return ""
+
+    def _write_table_iter(self, **kwargs: Any) -> None:
+        pass
+
+    def close(self) -> None:
+        pass
+
+    def _write_value_row_separator(self) -> None:
+        pass

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/__init__.py

@@ -0,0 +1,44 @@
+from ._asciidoc import AsciiDocTableWriter
+from ._borderless import BorderlessTableWriter
+from ._css import CssTableWriter
+from ._csv import CsvTableWriter
+from ._html import HtmlTableWriter
+from ._json import JsonTableWriter
+from ._jsonlines import JsonLinesTableWriter
+from ._latex import LatexMatrixWriter, LatexTableWriter
+from ._ltsv import LtsvTableWriter
+from ._markdown import MarkdownFlavor, MarkdownTableWriter, normalize_md_flavor
+from ._mediawiki import MediaWikiTableWriter
+from ._rst import RstCsvTableWriter, RstGridTableWriter, RstSimpleTableWriter
+from ._spacealigned import SpaceAlignedTableWriter
+from ._toml import TomlTableWriter
+from ._tsv import TsvTableWriter
+from ._unicode import BoldUnicodeTableWriter, UnicodeTableWriter
+from ._yaml import YamlTableWriter
+
+
+__all__ = (
+    "AsciiDocTableWriter",
+    "BoldUnicodeTableWriter",
+    "BorderlessTableWriter",
+    "CssTableWriter",
+    "CsvTableWriter",
+    "HtmlTableWriter",
+    "JsonTableWriter",
+    "JsonLinesTableWriter",
+    "LatexMatrixWriter",
+    "LatexTableWriter",
+    "LtsvTableWriter",
+    "MarkdownFlavor",
+    "MarkdownTableWriter",
+    "normalize_md_flavor",
+    "MediaWikiTableWriter",
+    "RstCsvTableWriter",
+    "RstGridTableWriter",
+    "RstSimpleTableWriter",
+    "SpaceAlignedTableWriter",
+    "TomlTableWriter",
+    "TsvTableWriter",
+    "UnicodeTableWriter",
+    "YamlTableWriter",
+)

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/_asciidoc.py

@@ -0,0 +1,146 @@
+import copy
+from typing import Any, List, Sequence
+
+import dataproperty as dp
+import typepy
+from dataproperty import ColumnDataProperty, DataProperty, LineBreakHandling
+from mbstrdecoder import MultiByteStrDecoder
+
+from ...style import (
+    Align,
+    FontStyle,
+    FontWeight,
+    Style,
+    StylerInterface,
+    TextStyler,
+    get_align_char,
+)
+from .._table_writer import AbstractTableWriter
+from ._text_writer import TextTableWriter
+
+
+class AsciiDocStyler(TextStyler):
+    def apply(self, value: str, style: Style) -> str:
+        value = super().apply(value, style)
+        if not value:
+            return value
+
+        try:
+            fg_color = style.fg_color.name.lower()  # type: ignore
+        except AttributeError:
+            fg_color = None
+
+        try:
+            bg_color = style.bg_color.name.lower()  # type: ignore
+        except AttributeError:
+            bg_color = None
+
+        if fg_color and bg_color:
+            value = f"[{fg_color} {bg_color}-background]##{value}##"
+        elif fg_color:
+            value = f"[{fg_color}]##{value}##"
+        elif bg_color:
+            value = f"[{bg_color}-background]##{value}##"
+
+        if style.font_weight == FontWeight.BOLD:
+            value = f"*{value}*"
+
+        if style.font_style == FontStyle.ITALIC:
+            value = f"_{value}_"
+
+        return value
+
+
+class AsciiDocTableWriter(TextTableWriter):
+    """
+    A table writer class for `AsciiDoc <https://asciidoc.org/>`__ format.
+    """
+
+    FORMAT_NAME = "asciidoc"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return True
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.column_delimiter = "\n"
+
+        self.is_padding = False
+        self.is_write_header_separator_row = True
+        self.is_write_value_separator_row = True
+        self.is_write_opening_row = True
+        self.is_write_closing_row = True
+
+        self.update_preprocessor(line_break_handling=LineBreakHandling.NOP)
+
+        self._quoting_flags = copy.deepcopy(dp.NOT_QUOTING_FLAGS)
+
+    def _create_styler(self, writer: AbstractTableWriter) -> StylerInterface:
+        return AsciiDocStyler(writer)
+
+    def _write_value_row(
+        self, row: int, values: Sequence[str], value_dp_list: Sequence[DataProperty]
+    ) -> None:
+        self._write_row(
+            row,
+            [
+                self.__modify_row_element(row, col_idx, value, value_dp)
+                for col_idx, (value, value_dp), in enumerate(zip(values, value_dp_list))
+            ],
+        )
+
+    def _get_opening_row_items(self) -> List[str]:
+        cols = ", ".join(
+            f"{get_align_char(col_dp.align)}{col_dp.ascii_char_width}"
+            for col_dp in self._column_dp_list
+        )
+        rows = [f'[cols="{cols}", options="header"]']
+
+        if typepy.is_not_null_string(self.table_name):
+            rows.append("." + MultiByteStrDecoder(self.table_name).unicode_str)
+
+        rows.append("|===")
+
+        return ["\n".join(rows)]
+
+    def _get_header_row_separator_items(self) -> List[str]:
+        return [""]
+
+    def _get_value_row_separator_items(self) -> List[str]:
+        return self._get_header_row_separator_items()
+
+    def _get_closing_row_items(self) -> List[str]:
+        return ["|==="]
+
+    def __apply_align(self, value: str, style: Style) -> str:
+        return f"{get_align_char(Align.CENTER)}|{value}"
+
+    def _apply_style_to_header_item(
+        self, col_dp: ColumnDataProperty, value_dp: DataProperty, style: Style
+    ) -> str:
+        value = self._styler.apply(col_dp.dp_to_str(value_dp), style=style)
+        return self.__apply_align(value, style)
+
+    def __modify_row_element(
+        self, row_idx: int, col_idx: int, value: str, value_dp: DataProperty
+    ) -> str:
+        col_dp = self._column_dp_list[col_idx]
+        style = self._fetch_style(row_idx, col_dp, value_dp)
+        align = col_dp.align
+
+        if style and style.align and style.align != align:
+            forma_stirng = "{0:s}|{1:s}"
+            align = style.align
+        elif value_dp.align != align:
+            forma_stirng = "{0:s}|{1:s}"
+            align = value_dp.align
+        else:
+            forma_stirng = "|{1:s}"
+
+        return forma_stirng.format(get_align_char(align), value)

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/_borderless.py

@@ -0,0 +1,41 @@
+import copy
+from typing import Any
+
+import dataproperty as dp
+
+from ._text_writer import IndentationTextTableWriter
+
+
+class BorderlessTableWriter(IndentationTextTableWriter):
+    """
+    A table writer class for borderless table.
+    """
+
+    FORMAT_NAME = "borderless"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return True
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.table_name = ""
+
+        self.column_delimiter = ""
+        self.char_left_side_row = ""
+        self.char_right_side_row = ""
+
+        self.indent_string = kwargs.get("indent_string", "    ")
+        self.is_write_header_separator_row = False
+        self.is_write_value_separator_row = False
+        self.is_write_opening_row = False
+        self.is_write_closing_row = False
+
+        self._quoting_flags = copy.deepcopy(dp.NOT_QUOTING_FLAGS)
+
+        self._init_cross_point_maps()

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/_common.py

@@ -0,0 +1,26 @@
+from decimal import Decimal
+from typing import Any
+
+from dataproperty import DataProperty
+from typepy import Typecode
+
+
+def bool_to_str(value: Any) -> Any:
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+
+    return value
+
+
+def serialize_dp(dp: DataProperty) -> Any:
+    if dp.typecode in (Typecode.REAL_NUMBER, Typecode.INFINITY, Typecode.NAN) and isinstance(
+        dp.data, Decimal
+    ):
+        return float(dp.data)
+
+    if dp.typecode == Typecode.DATETIME:
+        return dp.to_str()
+
+    return dp.data

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/_css.py

@@ -0,0 +1,157 @@
+import copy
+from typing import Any, List, cast
+
+from dataproperty import NOT_QUOTING_FLAGS, DataProperty
+from pathvalidate import replace_symbol
+
+from ...error import EmptyTableDataError
+from ...style import Align, DecorationLine, FontStyle, FontWeight, Style, VerticalAlign
+from .._common import HEADER_ROW
+from ._text_writer import IndentationTextTableWriter
+
+
+class CssTableWriter(IndentationTextTableWriter):
+    """
+    A CSS writer class.
+    """
+
+    FORMAT_NAME = "css"
+    MARGIN_PIXEL = 6
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return False
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.is_padding = False
+        self.indent_string = kwargs.get("indent_string", "    ")
+
+        self._dp_extractor.preprocessor.is_escape_html_tag = False
+        self._quoting_flags = copy.deepcopy(NOT_QUOTING_FLAGS)
+
+    def write_table(self, **kwargs: Any) -> None:
+        """
+        |write_table| with CSS.
+        """
+
+        with self._logger:
+            try:
+                self._verify_property()
+            except EmptyTableDataError:
+                self._logger.logger.debug("no tabular data found")
+                return
+
+            self._preprocess()
+
+            self.__write_css(
+                css_class=replace_symbol(self.table_name, replacement_text="-"),
+                write_style_tag=kwargs.get("write_style_tag", False),
+            )
+
+    def __extract_css_tags(self, value_dp: DataProperty, style: Style) -> List[str]:
+        css_tags: List[str] = []
+
+        if self._styler.get_font_size(style):
+            css_tags.append(cast(str, self._styler.get_font_size(style)))
+        if style.font_weight == FontWeight.BOLD:
+            css_tags.append("font-weight:bold")
+        if style.font_style == FontStyle.ITALIC:
+            css_tags.append("font-style:italic")
+
+        if style.color:
+            css_tags.append(f"color: {style.color.color_code}")
+
+        if style.bg_color:
+            css_tags.append(f"background-color: {style.bg_color.color_code}")
+
+        css_tag = self.__extract_align_tag(value_dp, style)
+        if css_tag:
+            css_tags.append(css_tag)
+
+        if style.vertical_align != VerticalAlign.BASELINE:
+            css_tags.append(f"vertical-align: {style.vertical_align.align_str}")
+
+        if style.decoration_line in (DecorationLine.LINE_THROUGH, DecorationLine.STRIKE):
+            css_tags.append("text-decoration-line: line-through")
+        elif style.decoration_line == DecorationLine.UNDERLINE:
+            css_tags.append("text-decoration-line: underline")
+
+        if self.margin > 0:
+            css_tags.append(f"padding: {self.margin * self.MARGIN_PIXEL}px")
+
+        return css_tags
+
+    def __extract_align_tag(self, value_dp: DataProperty, style: Style) -> str:
+        if style.align == Align.AUTO:
+            value = value_dp.align.align_string
+        else:
+            value = style.align.align_string
+
+        return f"text-align: {value}"
+
+    def __write_css_thead(self, css_class: str, base_indent_level: int) -> None:
+        for col_dp, header_dp in zip(self._column_dp_list, self._dp_extractor.to_header_dp_list()):
+            style = self._fetch_style(HEADER_ROW, col_dp, header_dp)
+            css_tags = self.__extract_css_tags(header_dp, style)
+
+            if not css_tags:
+                continue
+
+            self.set_indent_level(base_indent_level)
+            self._write_line(
+                ".{css_class} thead th:nth-child({col}) {{".format(
+                    css_class=css_class, col=col_dp.column_index + 1
+                )
+            )
+
+            self.set_indent_level(base_indent_level + 1)
+            for css_tag in css_tags:
+                self._write_line(f"{css_tag};")
+
+            self.set_indent_level(base_indent_level)
+            self._write_line("}")
+
+    def __write_css_tbody(self, css_class: str, base_indent_level: int) -> None:
+        for row_idx, (values, value_dp_list) in enumerate(
+            zip(self._table_value_matrix, self._table_value_dp_matrix)
+        ):
+            for value, value_dp, col_dp in zip(values, value_dp_list, self._column_dp_list):
+                style = self._fetch_style(row_idx, col_dp, value_dp)
+                css_tags = self.__extract_css_tags(value_dp, style)
+
+                if not css_tags:
+                    continue
+
+                self.set_indent_level(base_indent_level)
+                self._write_line(
+                    ".{css_class} tbody tr:nth-child({row}) td:nth-child({col}) {{".format(
+                        css_class=css_class, row=row_idx + 1, col=col_dp.column_index + 1
+                    )
+                )
+
+                self.set_indent_level(base_indent_level + 1)
+                for css_tag in css_tags:
+                    self._write_line(f"{css_tag};")
+
+                self.set_indent_level(base_indent_level)
+                self._write_line("}")
+
+    def __write_css(self, css_class: str, write_style_tag: bool = False) -> None:
+        base_indent_level = 0
+
+        if write_style_tag:
+            self._write_line('<style type="text/css">')
+            base_indent_level = 1
+
+        self.__write_css_thead(css_class, base_indent_level)
+        self.__write_css_tbody(css_class, base_indent_level)
+
+        if write_style_tag:
+            self.set_indent_level(0)
+            self._write_line("</style>")

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/_csv.py

@@ -0,0 +1,63 @@
+from typing import Any, List
+
+import typepy
+
+from ._text_writer import TextTableWriter
+
+
+class CsvTableWriter(TextTableWriter):
+    """
+    A table writer class for character separated values format.
+    The default separated character is a comma (``","``).
+
+        :Example:
+            :ref:`example-csv-table-writer`
+    """
+
+    FORMAT_NAME = "csv"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return True
+
+    @property
+    def margin(self) -> int:
+        return self._margin
+
+    @margin.setter
+    def margin(self, value: int) -> None:
+        # margin setting must be ignored
+        return
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self._set_chars("")
+        self.indent_string = ""
+        self.column_delimiter = kwargs.get("column_delimiter", ",")
+        self._margin = 0
+
+        self.is_padding = False
+        self.is_formatting_float = False
+        self.is_write_header_separator_row = False
+
+        self._quoting_flags[typepy.Typecode.NULL_STRING] = False
+
+    def _write_header(self) -> None:
+        if typepy.is_empty_sequence(self.headers):
+            return
+
+        super()._write_header()
+
+    def _get_opening_row_items(self) -> List[str]:
+        return []
+
+    def _get_value_row_separator_items(self) -> List[str]:
+        return []
+
+    def _get_closing_row_items(self) -> List[str]:
+        return []

llmeval-env/lib/python3.10/site-packages/pytablewriter/writer/text/_html.py

@@ -0,0 +1,194 @@
+import copy
+import warnings
+from typing import Any, List, Optional, Tuple, cast
+
+import dataproperty
+import typepy
+from mbstrdecoder import MultiByteStrDecoder
+from pathvalidate import replace_symbol
+
+from ...error import EmptyTableDataError
+from ...sanitizer import sanitize_python_var_name
+from ...style import Align, FontStyle, FontWeight, HtmlStyler, Style, StylerInterface, VerticalAlign
+from .._common import import_error_msg_template
+from .._table_writer import AbstractTableWriter
+from ._css import CssTableWriter
+from ._text_writer import TextTableWriter
+
+
+def _get_tags_module() -> Tuple:
+    try:
+        from dominate import tags
+        from dominate.util import raw
+
+        return tags, raw
+    except ImportError:
+        warnings.warn(import_error_msg_template.format("html"))
+        raise
+
+
+class HtmlTableWriter(TextTableWriter):
+    """
+    A table writer class for HTML format.
+
+        :Example:
+            :ref:`example-html-table-writer`
+    """
+
+    FORMAT_NAME = "html"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def support_split_write(self) -> bool:
+        return False
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.is_padding = False
+        self.indent_string = kwargs.get("indent_string", "    ")
+
+        self._dp_extractor.preprocessor.line_break_repl = "<br>"
+        self._dp_extractor.preprocessor.is_escape_html_tag = False
+        self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
+        self._table_tag: Any = None
+
+        self.enable_ansi_escape = False
+
+    def write_table(self, **kwargs: Any) -> None:
+        """
+        |write_table| with HTML table format.
+
+        Args:
+            write_css (bool):
+                If |True|, write CSS corresponding to the specified styles,
+                instead of attributes of HTML tags.
+
+        Example:
+            :ref:`example-html-table-writer`
+
+        .. note::
+            - |None| values will be replaced with an empty value
+        """
+
+        tags, raw = _get_tags_module()
+        write_css: bool = kwargs.get("write_css", False)
+
+        with self._logger:
+            try:
+                self._verify_property()
+            except EmptyTableDataError:
+                self._logger.logger.debug("no tabular data found")
+                return
+
+            self._preprocess()
+
+            css_class: Optional[str] = None
+
+            if write_css:
+                default_css_class_name = replace_symbol(self.table_name, replacement_text="-")
+                if default_css_class_name:
+                    default_css_class_name += "-css"
+                else:
+                    default_css_class_name = "ptw-table-css"
+
+                css_class = kwargs.get("css_class", default_css_class_name)
+                css_writer = CssTableWriter(
+                    table_name=css_class,
+                    margin=self.margin,
+                    stream=self.stream,
+                )
+                css_writer.from_writer(self, is_overwrite_table_name=False)
+                css_writer.write_table(write_style_tag=True)
+
+            if typepy.is_not_null_string(self.table_name):
+                if css_class:
+                    self._table_tag = tags.table(
+                        id=sanitize_python_var_name(self.table_name), class_name=css_class
+                    )
+                else:
+                    self._table_tag = tags.table(id=sanitize_python_var_name(self.table_name))
+                self._table_tag += tags.caption(MultiByteStrDecoder(self.table_name).unicode_str)
+            else:
+                if css_class:
+                    self._table_tag = tags.table(class_name=css_class)
+                else:
+                    self._table_tag = tags.table()
+
+            try:
+                self._write_header()
+            except ValueError:
+                pass
+
+            self._write_body(not write_css)
+
+    def _write_header(self) -> None:
+        tags, raw = _get_tags_module()
+
+        if not self.is_write_header:
+            return
+
+        if typepy.is_empty_sequence(self._table_headers):
+            raise ValueError("headers is empty")
+
+        tr_tag = tags.tr()
+        for header in self._table_headers:
+            tr_tag += tags.th(raw(MultiByteStrDecoder(header).unicode_str))
+
+        thead_tag = tags.thead()
+        thead_tag += tr_tag
+
+        self._table_tag += thead_tag
+
+    def _write_body(self, write_attr: bool) -> None:
+        tags, raw = _get_tags_module()
+        tbody_tag = tags.tbody()
+
+        for row_idx, (values, value_dp_list) in enumerate(
+            zip(self._table_value_matrix, self._table_value_dp_matrix)
+        ):
+            tr_tag = tags.tr()
+            for value, value_dp, column_dp in zip(values, value_dp_list, self._column_dp_list):
+                td_tag = tags.td(raw(MultiByteStrDecoder(value).unicode_str))
+
+                style = self._fetch_style(row_idx, column_dp, value_dp)
+
+                if write_attr:
+                    if style.align == Align.AUTO:
+                        td_tag["align"] = value_dp.align.align_string
+                    else:
+                        td_tag["align"] = style.align.align_string
+
+                    if style.vertical_align != VerticalAlign.BASELINE:
+                        td_tag["valign"] = style.vertical_align.align_str
+
+                    style_tag = self.__make_style_tag(style=style)
+                    if style_tag:
+                        td_tag["style"] = style_tag
+
+                tr_tag += td_tag
+            tbody_tag += tr_tag
+
+        self._table_tag += tbody_tag
+        self._write_line(self._table_tag.render(indent=self.indent_string))
+
+    def __make_style_tag(self, style: Style) -> Optional[str]:
+        styles: List[str] = []
+
+        if self._styler.get_font_size(style):
+            styles.append(cast(str, self._styler.get_font_size(style)))
+        if style.font_weight == FontWeight.BOLD:
+            styles.append("font-weight:bold")
+        if style.font_style == FontStyle.ITALIC:
+            styles.append("font-style:italic")
+
+        if not styles:
+            return None
+
+        return "; ".join(styles)
+
+    def _create_styler(self, writer: AbstractTableWriter) -> StylerInterface:
+        return HtmlStyler(writer)