Add files using upload-large-folder tool

ckpts/universal/global_step80/zero/16.mlp.dense_h_to_4h.weight/exp_avg_sq.pt

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

ckpts/universal/global_step80/zero/16.mlp.dense_h_to_4h.weight/fp32.pt

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

ckpts/universal/global_step80/zero/19.attention.dense.weight/fp32.pt

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

venv/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",
+)

venv/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}]'
+    """
+)

venv/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

venv/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

venv/lib/python3.10/site-packages/pytablewriter/writer/_msgfy.py

@@ -0,0 +1,56 @@
+"""
+Import from https://github.com/thombashi/msgfy
+"""
+
+import inspect
+import os.path
+from types import FrameType
+from typing import Optional
+
+
+DEFAULT_ERROR_MESSAGE_FORMAT = "{exception}: {error_msg}"
+DEFAULT_DEBUG_MESSAGE_FORMAT = "{exception} {file_name}({line_no}) {func_name}: {error_msg}"
+
+error_message_format = DEFAULT_ERROR_MESSAGE_FORMAT
+debug_message_format = DEFAULT_DEBUG_MESSAGE_FORMAT
+
+
+def _to_message(exception_obj: Exception, format_str: str, frame: Optional[FrameType]) -> str:
+    if not isinstance(exception_obj, Exception):
+        raise ValueError("exception_obj must be an instance of a subclass of the Exception class")
+
+    if frame is None:
+        return str(exception_obj)
+
+    try:
+        return (
+            format_str.replace("{exception}", exception_obj.__class__.__name__)
+            .replace("{file_name}", os.path.basename(frame.f_code.co_filename))
+            .replace("{line_no}", str(frame.f_lineno))
+            .replace("{func_name}", frame.f_code.co_name)
+            .replace("{error_msg}", str(exception_obj))
+        )
+    except AttributeError:
+        raise ValueError("format_str must be a string")
+
+
+def to_error_message(exception_obj: Exception, format_str: Optional[str] = None) -> str:
+    if not format_str:
+        format_str = error_message_format
+
+    frame = inspect.currentframe()
+    if frame is None:
+        return str(exception_obj)
+
+    return _to_message(exception_obj, format_str, frame.f_back)
+
+
+def to_debug_message(exception_obj: Exception, format_str: Optional[str] = None) -> str:
+    if not format_str:
+        format_str = debug_message_format
+
+    frame = inspect.currentframe()
+    if frame is None:
+        return str(exception_obj)
+
+    return _to_message(exception_obj, format_str, frame.f_back)

venv/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

venv/lib/python3.10/site-packages/pytablewriter/writer/_table_writer.py

@@ -0,0 +1,1245 @@
+"""
+.. codeauthor:: Tsuyoshi Hombashi <[email protected]>
+"""
+
+import abc
+import copy
+import math
+import warnings
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Sequence, Union, cast
+
+import typepy
+from dataproperty import (
+    Align,
+    ColumnDataProperty,
+    DataProperty,
+    DataPropertyExtractor,
+    Format,
+    MatrixFormatting,
+    Preprocessor,
+)
+from dataproperty.typing import TransFunc
+from tabledata import TableData, convert_idx_to_alphabet, to_value_matrix
+from typepy import Typecode, extract_typepy_from_dtype
+
+from .._logger import WriterLogger
+from ..error import EmptyTableDataError, EmptyTableNameError, EmptyValueError, NotSupportedError
+from ..style import (
+    Cell,
+    CheckStyleFilterKeywordArgsFunc,
+    ColSeparatorStyleFilterFunc,
+    Style,
+    StyleFilterFunc,
+    StylerInterface,
+    ThousandSeparator,
+    fetch_theme,
+)
+from ..typehint import Integer, TypeHint
+from ._common import HEADER_ROW
+from ._interface import TableWriterInterface
+from ._msgfy import to_error_message
+
+
+if TYPE_CHECKING:
+    import pandas
+    import tablib
+
+    from .._table_format import TableFormat
+
+_ts_to_flag: Dict[ThousandSeparator, int] = {
+    ThousandSeparator.NONE: Format.NONE,
+    ThousandSeparator.COMMA: Format.THOUSAND_SEPARATOR,
+    ThousandSeparator.SPACE: Format.THOUSAND_SEPARATOR,
+    ThousandSeparator.UNDERSCORE: Format.THOUSAND_SEPARATOR,
+}
+
+
+def header_style_filter(cell: Cell, **kwargs: Any) -> Optional[Style]:
+    if cell.is_header_row():
+        return Style(align=Align.CENTER)
+
+    return None
+
+
+DEFAULT_STYLE_FILTERS: List[StyleFilterFunc] = [header_style_filter]
+
+
+class AbstractTableWriter(TableWriterInterface, metaclass=abc.ABCMeta):
+    """
+    An abstract base class of table writer classes.
+
+    Args:
+        max_precision (int): Maximum decimal places for real number values.
+
+        dequote (bool): If |True|, dequote values in :py:attr:`~.value_matrix`.
+
+    .. py:attribute:: stream
+
+        Stream to write tables.
+        You can use arbitrary streams which support ``write``methods
+        such as ``sys.stdout``, file stream, ``StringIO``, and so forth.
+        Defaults to ``sys.stdout``.
+
+        :Example:
+            :ref:`example-configure-stream`
+
+    .. py:attribute:: is_write_header
+        :type: bool
+
+        Write headers of a table if the value is |True|.
+
+    .. py:attribute:: is_padding
+        :type: bool
+
+        Padding for each item in the table if the value is |True|.
+
+    .. py:attribute:: iteration_length
+        :type: int
+
+        The number of iterations to write a table.
+        This value is used in :py:meth:`.write_table_iter` method.
+        (defaults to ``-1``, which means the number of iterations is indefinite)
+
+    .. py:attribute:: style_filter_kwargs
+        :type: Dict[str, Any]
+
+        Extra keyword arguments for style filter functions.
+        These arguments will pass to filter functions added by
+        :py:meth:`.add_style_filter` or :py:meth:`.add_col_separator_style_filter`
+
+    .. py:attribute:: colorize_terminal
+        :type: bool
+        :value: True
+
+        [Only available for text format writers] [experimental]
+        If |True|, colorize text outputs with |Style|.
+
+    .. py:attribute:: enable_ansi_escape
+        :type: bool
+        :value: True
+
+        [Only available for text format writers]
+        If |True|, applies ANSI escape sequences to the terminal's text outputs with |Style|.
+
+    .. py:attribute:: write_callback
+
+        The value expected to a function.
+        The function is called when each of the iterations of writing a table
+        completed. (defaults to |None|)
+        For example, a callback function definition is as follows:
+
+        .. code:: python
+
+            def callback_example(iter_count: int, iter_length: int) -> None:
+                print("{:d}/{:d}".format(iter_count, iter_length))
+
+        Arguments that passed to the callback are:
+
+        - first argument: current iteration number (start from ``1``)
+        - second argument: a total number of iteration
+    """
+
+    @property
+    def margin(self) -> int:
+        raise NotImplementedError()
+
+    @margin.setter
+    def margin(self, value: int) -> None:
+        raise NotImplementedError()
+
+    @property
+    def value_matrix(self) -> Sequence:
+        """Data of a table to be outputted."""
+
+        return self.__value_matrix_org
+
+    @value_matrix.setter
+    def value_matrix(self, value_matrix: Sequence) -> None:
+        self.__set_value_matrix(value_matrix)
+        self.__clear_preprocess()
+
+    @property
+    def table_format(self) -> "TableFormat":
+        """TableFormat: Get the format of the writer."""
+
+        from .._table_format import TableFormat
+
+        table_format = TableFormat.from_name(self.format_name)
+        assert table_format
+
+        return table_format
+
+    @property
+    def stream(self) -> Any:
+        return self._stream
+
+    @stream.setter
+    def stream(self, value: Any) -> None:
+        self._stream = value
+
+    @abc.abstractmethod
+    def _write_table(self, **kwargs: Any) -> None:
+        pass
+
+    def __init__(self, **kwargs: Any) -> None:
+        self._logger = WriterLogger(self)
+
+        self.table_name = kwargs.get("table_name", "")
+        self.value_matrix = kwargs.get("value_matrix", [])
+
+        self.is_write_header = kwargs.get("is_write_header", True)
+        self.is_write_header_separator_row = kwargs.get("is_write_header_separator_row", True)
+        self.is_write_value_separator_row = kwargs.get("is_write_value_separator_row", False)
+        self.is_write_opening_row = kwargs.get("is_write_opening_row", False)
+        self.is_write_closing_row = kwargs.get("is_write_closing_row", False)
+
+        self._use_default_header = False
+
+        self._dp_extractor = DataPropertyExtractor(max_precision=kwargs.get("max_precision"))
+        self._dp_extractor.min_column_width = 1
+        self._dp_extractor.strip_str_header = '"'
+        self._dp_extractor.preprocessor = Preprocessor(dequote=kwargs.get("dequote", True))
+        self._dp_extractor.type_value_map[Typecode.NONE] = ""
+        self._dp_extractor.matrix_formatting = MatrixFormatting.HEADER_ALIGNED
+        self._dp_extractor.update_strict_level_map({Typecode.BOOL: 1})
+
+        self.is_formatting_float = kwargs.get("is_formatting_float", True)
+        self.is_padding = kwargs.get("is_padding", True)
+
+        self.headers = kwargs.get("headers", [])
+        self.type_hints = kwargs.get("type_hints", [])
+        self._quoting_flags = {
+            Typecode.BOOL: False,
+            Typecode.DATETIME: True,
+            Typecode.DICTIONARY: False,
+            Typecode.INFINITY: False,
+            Typecode.INTEGER: False,
+            Typecode.IP_ADDRESS: True,
+            Typecode.LIST: False,
+            Typecode.NAN: False,
+            Typecode.NONE: False,
+            Typecode.NULL_STRING: True,
+            Typecode.REAL_NUMBER: False,
+            Typecode.STRING: True,
+        }
+
+        self._is_require_table_name = False
+        self._is_require_header = False
+
+        self.iteration_length: int = kwargs.get("iteration_length", -1)
+        self.write_callback = kwargs.get(
+            "write_callback", lambda _iter_count, _iter_length: None  # defaults to NOP callback
+        )
+        self._iter_count: Optional[int] = None
+
+        self.__default_style: Style
+        self.default_style = kwargs.get("default_style", Style())
+
+        self.__col_style_list: List[Optional[Style]] = []
+        self.column_styles = kwargs.get("column_styles", [])
+
+        self._style_filters: List[StyleFilterFunc] = copy.deepcopy(DEFAULT_STYLE_FILTERS)
+        self._enable_style_filter = True
+        self._styler = self._create_styler(self)
+        self.style_filter_kwargs: Dict[str, Any] = kwargs.get("style_filter_kwargs", {})
+        self._check_style_filter_kwargs_funcs: List[CheckStyleFilterKeywordArgsFunc] = []
+        self.__colorize_terminal = kwargs.get("colorize_terminal", True)
+        self.__enable_ansi_escape = kwargs.get("enable_ansi_escape", True)
+
+        self.max_workers = kwargs.get("max_workers", 1)
+
+        if "dataframe" in kwargs:
+            self.from_dataframe(kwargs["dataframe"])
+
+        self.__clear_preprocess()
+
+    def _repr_html_(self) -> str:
+        from .text._html import HtmlTableWriter
+
+        writer = HtmlTableWriter(
+            table_name=self.table_name,
+            headers=self.headers,
+            value_matrix=self.value_matrix,
+            column_styles=self.column_styles,
+            colorize_terminal=self.colorize_terminal,
+            enable_ansi_escape=self.enable_ansi_escape,
+        )
+        writer._dp_extractor = self._dp_extractor
+
+        return writer.dumps()
+
+    @property
+    def value_preprocessor(self) -> Preprocessor:
+        return self._dp_extractor.preprocessor
+
+    def __clear_preprocess_status(self) -> None:
+        self._is_complete_table_dp_preprocess = False
+        self._is_complete_table_property_preprocess = False
+        self._is_complete_header_preprocess = False
+        self._is_complete_value_matrix_preprocess = False
+
+    def __clear_preprocess_data(self) -> None:
+        self._column_dp_list: List[ColumnDataProperty] = []
+        self._table_headers: List[str] = []
+        self._table_value_matrix: List[Union[List[str], Dict]] = []
+        self._table_value_dp_matrix: Sequence[Sequence[DataProperty]] = []
+
+    @property
+    def headers(self) -> Sequence[str]:
+        """Sequence[str]: Headers of a table to be outputted."""
+
+        return self._dp_extractor.headers
+
+    @headers.setter
+    def headers(self, value: Sequence[str]) -> None:
+        self._dp_extractor.headers = value
+
+    @property
+    def is_formatting_float(self) -> bool:
+        return self._dp_extractor.is_formatting_float
+
+    @is_formatting_float.setter
+    def is_formatting_float(self, value: bool) -> None:
+        if self._dp_extractor.is_formatting_float == value:
+            return
+
+        self._dp_extractor.is_formatting_float = value
+        self.__clear_preprocess()
+
+    @property
+    def max_workers(self) -> int:
+        return self._dp_extractor.max_workers
+
+    @max_workers.setter
+    def max_workers(self, value: Optional[int]) -> None:
+        self._dp_extractor.max_workers = value
+
+    @property
+    def tabledata(self) -> TableData:
+        """tabledata.TableData: Get tabular data of the writer."""
+
+        return TableData(
+            self.table_name,
+            self.headers,
+            self.value_matrix,
+            max_workers=self.max_workers,
+            max_precision=self._dp_extractor.max_precision,
+        )
+
+    @property
+    def table_name(self) -> str:
+        """str: Name of a table."""
+
+        return self._table_name
+
+    @table_name.setter
+    def table_name(self, value: str) -> None:
+        self._table_name = value
+
+    @property
+    def type_hints(self) -> List[TypeHint]:
+        """
+        Type hints for each column of the tabular data.
+        Writers convert data for each column using the type hints information
+        before writing tables when you call ``write_xxx`` methods.
+
+        Acceptable values are as follows:
+
+            - |None| (automatically detect column type from values in the column)
+            - :py:class:`pytablewriter.typehint.Bool` or ``"bool"``
+            - :py:class:`pytablewriter.typehint.DateTime` or ``"datetime"``
+            - :py:class:`pytablewriter.typehint.Dictionary` or ``"dict"``
+            - :py:class:`pytablewriter.typehint.Infinity` or ``"inf"``
+            - :py:class:`pytablewriter.typehint.Integer` or ``"int"``
+            - :py:class:`pytablewriter.typehint.IpAddress` or ``"ipaddr"``
+            - :py:class:`pytablewriter.typehint.List` or ``"list"``
+            - :py:class:`pytablewriter.typehint.Nan` or ``"nan"``
+            - :py:class:`pytablewriter.typehint.NoneType` or ``"none"``
+            - :py:class:`pytablewriter.typehint.NullString` or ``"nullstr"``
+            - :py:class:`pytablewriter.typehint.RealNumber` or ``"realnumber"`` or ``"float"``
+            - :py:class:`pytablewriter.typehint.String` or ``"str"``
+
+        If a type-hint value is not |None|, the writer tries to
+        convert data for each data in a column to type-hint class.
+        If the type-hint value is |None| or failed to convert data,
+        the writer automatically detects column data type from
+        the column data.
+
+        If ``type_hints`` is |None|, the writer automatically detects data types
+        for all of the columns and writes a table using detected column types.
+
+        Defaults to |None|.
+
+        Examples:
+            - :ref:`example-type-hint-js`
+            - :ref:`example-type-hint-python`
+        """
+
+        return self._dp_extractor.column_type_hints
+
+    @type_hints.setter
+    def type_hints(self, value: Sequence[Union[str, TypeHint]]) -> None:
+        hints = list(value)
+        if self.type_hints == hints:
+            return
+
+        self.__set_type_hints(hints)
+        self.__clear_preprocess()
+
+    @property
+    def default_style(self) -> Style:
+        """Style: Default |Style| of table cells."""
+
+        return self.__default_style
+
+    @default_style.setter
+    def default_style(self, style: Optional[Style]) -> None:
+        if style is None:
+            style = Style()
+
+        if not isinstance(style, Style):
+            raise TypeError("default_style must be a Style instance")
+
+        try:
+            if self.__default_style == style:
+                return
+        except AttributeError:
+            # not yet initialized
+            pass
+
+        self.__default_style = style
+        self._dp_extractor.default_format_flags = _ts_to_flag[
+            self.__default_style.thousand_separator
+        ]
+        self.__clear_preprocess()
+
+    @property
+    def column_styles(self) -> List[Optional[Style]]:
+        """List[Optional[Style]]: |Style| for each column."""
+
+        return self.__col_style_list
+
+    @column_styles.setter
+    def column_styles(self, value: Sequence[Optional[Style]]) -> None:
+        if self.__col_style_list == value:
+            return
+
+        self.__col_style_list = list(value)
+
+        if self.__col_style_list:
+            self._dp_extractor.format_flags_list = [
+                _ts_to_flag[self._get_col_style(col_idx).thousand_separator]
+                for col_idx in range(len(self.__col_style_list))
+            ]
+        else:
+            self._dp_extractor.format_flags_list = []
+
+        self.__clear_preprocess()
+
+    @property
+    def colorize_terminal(self) -> bool:
+        return self.__colorize_terminal
+
+    @colorize_terminal.setter
+    def colorize_terminal(self, value: bool) -> None:
+        if self.__colorize_terminal == value:
+            return
+
+        self.__colorize_terminal = value
+        self.__clear_preprocess()
+
+    @property
+    def enable_ansi_escape(self) -> bool:
+        return self.__enable_ansi_escape
+
+    @enable_ansi_escape.setter
+    def enable_ansi_escape(self, value: bool) -> None:
+        if self.__enable_ansi_escape == value:
+            return
+
+        self.__enable_ansi_escape = value
+        self.__clear_preprocess()
+
+    @property
+    def _quoting_flags(self) -> Dict[Typecode, bool]:
+        return self._dp_extractor.quoting_flags
+
+    @_quoting_flags.setter
+    def _quoting_flags(self, value: Mapping[Typecode, bool]) -> None:
+        self._dp_extractor.quoting_flags = value
+        self.__clear_preprocess()
+
+    def add_style_filter(self, style_filter: StyleFilterFunc) -> None:
+        """Add a style filter function to the writer.
+
+        Args:
+            style_filter:
+                A function called for each table cell to apply a style to table cells.
+                The function will be required to implement the following Protocol:
+
+                .. code-block:: python
+
+                    class StyleFilterFunc(Protocol):
+                        def __call__(self, cell: Cell, **kwargs: Any) -> Optional[Style]:
+                            ...
+
+                If more than one style filter function is added to the writer,
+                it will be called from the last one added.
+                These style functions should return |None| when not needed to apply styles.
+                If all of the style functions returned |None|,
+                :py:attr:`~.default_style` will be used.
+
+                You can pass keyword arguments to style filter functions via
+                :py:attr:`~.style_filter_kwargs`. In default, the attribute includes:
+
+                    - ``writer``: the writer instance that the caller of a ``style_filter function``
+        """
+
+        self._style_filters.insert(0, style_filter)
+        self.__clear_preprocess()
+
+    def add_col_separator_style_filter(self, style_filter: ColSeparatorStyleFilterFunc) -> None:
+        self._logger.logger.debug(
+            "add_col_separator_style_filter method is only implemented in text format writer classes"
+        )
+
+    def clear_theme(self) -> None:
+        """Remove all of the style filters."""
+
+        if not self._style_filters:
+            return
+
+        self._style_filters = copy.deepcopy(DEFAULT_STYLE_FILTERS)
+        self._check_style_filter_kwargs_funcs = []
+        self.__clear_preprocess()
+
+    def enable_style_filter(self) -> None:
+        """Enable style filters."""
+
+        if self._enable_style_filter is True:
+            return
+
+        self._enable_style_filter = True
+        self.__clear_preprocess()
+
+    def disable_style_filter(self, clear_filters: bool = False) -> None:
+        """Disable style filters.
+
+        Args:
+            clear_filters (bool):
+                If |True|, clear all of the style filters.
+                Defaults to |False|.
+        """
+
+        if clear_filters:
+            self.clear_theme()
+            return
+
+        if self._enable_style_filter is False:
+            return
+
+        self._enable_style_filter = False
+        self.__clear_preprocess()
+
+    def set_style(self, column: Union[str, int], style: Style) -> None:
+        """Set |Style| for a specific column.
+
+        Args:
+            column (|int| or |str|):
+                Column specifier. Column index or header name correlated with the column.
+            style (|Style|):
+                Style value to be set to the column.
+
+        Raises:
+            ValueError: Raised when the column specifier is invalid.
+        """
+
+        column_idx = None
+
+        while len(self.headers) > len(self.__col_style_list):
+            self.__col_style_list.append(None)
+
+        if isinstance(column, int):
+            column_idx = column
+        elif isinstance(column, str):
+            try:
+                column_idx = self.headers.index(column)
+            except ValueError:
+                pass
+
+        if column_idx is not None:
+            self.__col_style_list[column_idx] = style
+            self.__clear_preprocess()
+            self._dp_extractor.format_flags_list = [
+                _ts_to_flag[self._get_col_style(col_idx).thousand_separator]
+                for col_idx in range(len(self.__col_style_list))
+            ]
+            return
+
+        raise ValueError(f"column must be an int or string: actual={column}")
+
+    def set_theme(self, theme: str, **kwargs: Any) -> None:
+        """Set style filters for a theme.
+
+        Args:
+            theme (str):
+                Name of the theme. pytablewriter theme plugin must be installed
+                corresponding to the theme name.
+
+        Raises:
+            RuntimeError: Raised when a theme plugin does not install.
+        """
+
+        try:
+            fetched_theme = fetch_theme(theme.strip())
+        except RuntimeError as e:
+            warnings.warn(f"{e}", UserWarning)
+            return
+
+        if fetched_theme.style_filter:
+            self.add_style_filter(fetched_theme.style_filter)
+
+        if fetched_theme.col_separator_style_filter:
+            self.add_col_separator_style_filter(fetched_theme.col_separator_style_filter)
+
+        if fetched_theme.check_style_filter_kwargs:
+            self._check_style_filter_kwargs_funcs.append(fetched_theme.check_style_filter_kwargs)
+
+        self.style_filter_kwargs.update(**kwargs)
+
+    def __is_skip_close(self) -> bool:
+        try:
+            from _pytest.capture import EncodedFile
+
+            if isinstance(self.stream, EncodedFile):
+                # avoid closing streams for pytest
+                return True
+        except ImportError:
+            pass
+
+        try:
+            from _pytest.capture import CaptureIO
+
+            if isinstance(self.stream, CaptureIO):
+                # avoid closing streams for pytest
+                return True
+        except ImportError:
+            try:
+                # for pytest 5.4.1 or older versions
+                from _pytest.compat import CaptureIO
+
+                if isinstance(self.stream, CaptureIO):
+                    # avoid closing streams for pytest
+                    return True
+            except ImportError:
+                pass
+
+        try:
+            from ipykernel.iostream import OutStream
+
+            if isinstance(self.stream, OutStream):
+                # avoid closing streams for Jupyter Notebook
+                return True
+        except ImportError:
+            pass
+
+        return False
+
+    def close(self) -> None:
+        """
+        Close the current |stream|.
+        """
+
+        if self.stream is None:
+            return
+
+        try:
+            self.stream.isatty()
+
+            if self.stream.name in ["<stdin>", "<stdout>", "<stderr>"]:
+                return
+        except AttributeError:
+            pass
+        except ValueError:
+            # raised when executing an operation to a closed stream
+            pass
+
+        if self.__is_skip_close():
+            return
+
+        try:
+            self.stream.close()
+        except AttributeError:
+            self._logger.logger.warning(
+                f"the stream has no close method implementation: type={type(self.stream)}"
+            )
+        finally:
+            self._stream = None
+
+    def from_tabledata(self, value: TableData, is_overwrite_table_name: bool = True) -> None:
+        """
+        Set tabular attributes to the writer from |TableData|.
+        The following attributes are configured:
+
+        - :py:attr:`~.table_name`.
+        - :py:attr:`~.headers`.
+        - :py:attr:`~.value_matrix`.
+
+        |TableData| can be created from various data formats by
+        ``pytablereader``. More detailed information can be found in
+        https://pytablereader.rtfd.io/en/latest/
+
+        :param tabledata.TableData value: Input table data.
+        """
+
+        self.__clear_preprocess()
+
+        if is_overwrite_table_name:
+            self.table_name = value.table_name if value.table_name else ""
+
+        self.headers = value.headers
+        self.value_matrix = list(value.rows)
+
+        if not value.has_value_dp_matrix:
+            return
+
+        self._table_value_dp_matrix = value.value_dp_matrix
+        self._column_dp_list = self._dp_extractor.to_column_dp_list(
+            self._table_value_dp_matrix, self._column_dp_list
+        )
+        self.__set_type_hints([col_dp.type_class for col_dp in self._column_dp_list])
+
+        self._is_complete_table_dp_preprocess = True
+
+    def from_csv(self, csv_source: str, delimiter: str = ",") -> None:
+        """
+        Set tabular attributes to the writer from a character-separated values (CSV) data source.
+        The following attributes are set to the writer by the method:
+
+        - :py:attr:`~.headers`.
+        - :py:attr:`~.value_matrix`.
+
+        :py:attr:`~.table_name` also be set if the CSV data source is a file.
+        In that case, :py:attr:`~.table_name` is as same as the filename.
+
+        Args:
+            csv_source (str):
+                Input CSV data source can be designated CSV text or a CSV file path.
+
+            delimiter (str):
+                Delimiter character of the CSV data source.
+                Defaults to ``,``.
+
+        Examples:
+            :ref:`example-from-csv`
+
+        :Dependency Packages:
+            - `pytablereader <https://github.com/thombashi/pytablereader>`__
+        """
+
+        import pytablereader as ptr
+
+        loader = ptr.CsvTableTextLoader(csv_source, quoting_flags=self._quoting_flags)
+        loader.delimiter = delimiter
+        try:
+            for table_data in loader.load():
+                self.from_tabledata(table_data, is_overwrite_table_name=False)
+            return
+        except ptr.DataError:
+            pass
+
+        loader = ptr.CsvTableFileLoader(csv_source, quoting_flags=self._quoting_flags)
+        loader.delimiter = delimiter
+        for table_data in loader.load():
+            self.from_tabledata(table_data)
+
+    def from_dataframe(
+        self,
+        dataframe: "pandas.DataFrame",
+        add_index_column: bool = False,
+        overwrite_type_hints: bool = True,
+    ) -> None:
+        """
+        Set tabular attributes to the writer from :py:class:`pandas.DataFrame`.
+        The following attributes are set by the method:
+
+            - :py:attr:`~.headers`
+            - :py:attr:`~.value_matrix`
+            - :py:attr:`~.type_hints`
+
+        Args:
+            dataframe(pandas.DataFrame or |str|):
+                Input pandas.DataFrame object or path to a DataFrame pickle.
+            add_index_column(bool, optional):
+                If |True|, add a column of ``index`` of the ``dataframe``.
+                Defaults to |False|.
+            overwrite_type_hints(bool):
+                If |True|, Overwrite type hints with dtypes within the DataFrame.
+
+        Example:
+            :ref:`example-from-pandas-dataframe`
+        """
+
+        if typepy.String(dataframe).is_type():
+            import pandas as pd
+
+            dataframe = pd.read_pickle(dataframe)
+
+        self.headers = list(dataframe.columns.values)
+
+        if not self.type_hints or overwrite_type_hints:
+            self.type_hints = [extract_typepy_from_dtype(dtype) for dtype in dataframe.dtypes]
+
+        if add_index_column:
+            self.headers = [" "] + self.headers
+            if self.type_hints:
+                self.type_hints = [Integer] + self.type_hints
+            self.value_matrix = [
+                [index] + row
+                for index, row in zip(dataframe.index.tolist(), dataframe.values.tolist())
+            ]
+        else:
+            self.value_matrix = dataframe.values.tolist()
+
+    def from_series(self, series: "pandas.Series", add_index_column: bool = True) -> None:
+        """
+        Set tabular attributes to the writer from :py:class:`pandas.Series`.
+        The following attributes are set by the method:
+
+            - :py:attr:`~.headers`
+            - :py:attr:`~.value_matrix`
+            - :py:attr:`~.type_hints`
+
+        Args:
+            series(pandas.Series):
+                Input pandas.Series object.
+            add_index_column(bool, optional):
+                If |True|, add a column of ``index`` of the ``series``.
+                Defaults to |True|.
+        """
+
+        if series.name:
+            self.headers = [series.name]
+        else:
+            self.headers = ["value"]
+
+        self.type_hints = [extract_typepy_from_dtype(series.dtype)]
+
+        if add_index_column:
+            self.headers = [""] + self.headers
+            if self.type_hints:
+                self.type_hints = [None] + self.type_hints
+            self.value_matrix = [
+                [index] + [value] for index, value in zip(series.index.tolist(), series.tolist())
+            ]
+        else:
+            self.value_matrix = [[value] for value in series.tolist()]
+
+    def from_tablib(self, tablib_dataset: "tablib.Dataset") -> None:
+        """
+        Set tabular attributes to the writer from :py:class:`tablib.Dataset`.
+        """
+
+        self.headers = tablib_dataset.headers
+        self.value_matrix = [row for row in tablib_dataset]
+
+    def from_writer(
+        self, writer: "AbstractTableWriter", is_overwrite_table_name: bool = True
+    ) -> None:
+        """
+        Copy attributes from another table writer class instance.
+
+        Args:
+            writer (pytablewriter.writer.AbstractTableWriter):
+                Another table writer instance.
+            is_overwrite_table_name (bool, optional):
+                Overwrite the table name of the writer with the table name of the ``writer``.
+                Defaults to |True|.
+        """
+
+        self.__clear_preprocess()
+
+        if is_overwrite_table_name:
+            self.table_name = str(writer.table_name)
+
+        self.headers = writer.headers
+        self.value_matrix = writer.value_matrix
+
+        self.type_hints = writer.type_hints
+        self.column_styles = writer.column_styles
+        self._style_filters = writer._style_filters
+        self.style_filter_kwargs = writer.style_filter_kwargs
+        self.margin = writer.margin
+
+        self._table_headers = writer._table_headers
+        self._table_value_dp_matrix = writer._table_value_dp_matrix
+        self._column_dp_list = writer._column_dp_list
+        self._table_value_matrix = writer._table_value_matrix
+
+        self.stream = writer.stream
+
+        self._is_complete_table_dp_preprocess = writer._is_complete_table_dp_preprocess
+        self._is_complete_table_property_preprocess = writer._is_complete_table_property_preprocess
+        self._is_complete_header_preprocess = writer._is_complete_header_preprocess
+        self._is_complete_value_matrix_preprocess = writer._is_complete_value_matrix_preprocess
+
+    def register_trans_func(self, trans_func: TransFunc) -> None:
+        self._dp_extractor.register_trans_func(trans_func)
+        self.__clear_preprocess()
+
+    def update_preprocessor(self, **kwargs: Any) -> None:
+        # TODO: documentation
+        #   is_escape_formula_injection: for CSV/Excel
+
+        if not self._dp_extractor.update_preprocessor(**kwargs):
+            return
+
+        self.__clear_preprocess()
+
+    def write_table(self, **kwargs: Any) -> None:
+        """
+        |write_table|.
+        """
+
+        with self._logger:
+            try:
+                self._verify_property()
+            except EmptyTableDataError:
+                self._logger.logger.debug("no tabular data found")
+                return
+
+            self._write_table(**kwargs)
+
+    def _write_table_iter(self, **kwargs: Any) -> None:
+        if not self.support_split_write:
+            raise NotSupportedError("the class not supported the write_table_iter method")
+
+        self._verify_style_filter_kwargs()
+        self._verify_table_name()
+        self._verify_stream()
+
+        if all(
+            [typepy.is_empty_sequence(self.headers), typepy.is_empty_sequence(self.value_matrix)]
+        ):
+            self._logger.logger.debug("no tabular data found")
+            return
+
+        self._verify_header()
+
+        self._logger.logger.debug(f"_write_table_iter: iteration-length={self.iteration_length:d}")
+
+        stash_is_write_header = self.is_write_header
+        stach_is_write_opening_row = self.is_write_opening_row
+        stash_is_write_closing_row = self.is_write_closing_row
+
+        try:
+            self.is_write_closing_row = False
+            self._iter_count = 1
+
+            for work_matrix in self.value_matrix:
+                is_final_iter = all(
+                    [self.iteration_length > 0, self._iter_count >= self.iteration_length]
+                )
+
+                if is_final_iter:
+                    self.is_write_closing_row = True
+
+                self.__set_value_matrix(work_matrix)
+                self.__clear_preprocess_status()
+
+                with self._logger:
+                    self._write_table(**kwargs)
+
+                    if not is_final_iter:
+                        self._write_value_row_separator()
+
+                self.is_write_opening_row = False
+                self.is_write_header = False
+
+                self.write_callback(self._iter_count, self.iteration_length)
+
+                # update typehint for the next iteration
+                """
+                if self.type_hints is None:
+                    self.__set_type_hints([
+                        column_dp.type_class for column_dp in self._column_dp_list
+                    ])
+                """
+
+                if is_final_iter:
+                    break
+
+                self._iter_count += 1
+        finally:
+            self.is_write_header = stash_is_write_header
+            self.is_write_opening_row = stach_is_write_opening_row
+            self.is_write_closing_row = stash_is_write_closing_row
+            self._iter_count = None
+
+    def _get_padding_len(
+        self, column_dp: ColumnDataProperty, value_dp: Optional[DataProperty] = None
+    ) -> int:
+        if not self.is_padding:
+            return 0
+
+        try:
+            return cast(DataProperty, value_dp).get_padding_len(column_dp.ascii_char_width)
+        except AttributeError:
+            return column_dp.ascii_char_width
+
+    def _to_header_item(self, col_dp: ColumnDataProperty, value_dp: DataProperty) -> str:
+        style = self._fetch_style(HEADER_ROW, col_dp, value_dp)
+        header = self._apply_style_to_header_item(col_dp, value_dp, style)
+        header = self._styler.apply_terminal_style(header, style=style)
+
+        return header
+
+    def _apply_style_to_header_item(
+        self, col_dp: ColumnDataProperty, value_dp: DataProperty, style: Style
+    ) -> str:
+        return self._styler.apply_align(
+            self._styler.apply(col_dp.dp_to_str(value_dp), style=style), style=style
+        )
+
+    def _to_row_item(self, row_idx: int, col_dp: ColumnDataProperty, value_dp: DataProperty) -> str:
+        style = self._fetch_style(row_idx, col_dp, value_dp)
+        value = self._apply_style_to_row_item(row_idx, col_dp, value_dp, style)
+
+        return self._styler.apply_terminal_style(value, style=style)
+
+    def _apply_style_to_row_item(
+        self, row_idx: int, col_dp: ColumnDataProperty, value_dp: DataProperty, style: Style
+    ) -> str:
+        return self._styler.apply_align(
+            self._styler.apply(col_dp.dp_to_str(value_dp), style=style), style=style
+        )
+
+    def _fetch_style_from_filter(
+        self, row_idx: int, col_dp: ColumnDataProperty, value_dp: DataProperty, default_style: Style
+    ) -> Style:
+        if not self._enable_style_filter:
+            return default_style
+
+        self.style_filter_kwargs.update({"writer": self})
+
+        style: Optional[Style] = None
+        for style_filter in self._style_filters:
+            style = style_filter(
+                Cell(
+                    row=row_idx,
+                    col=col_dp.column_index,
+                    value=value_dp.data,
+                    default_style=default_style,
+                ),
+                **self.style_filter_kwargs,
+            )
+            if style:
+                break
+
+        if style is None:
+            style = copy.deepcopy(default_style)
+
+        if style.align is None or (style.align == Align.AUTO and row_idx >= 0):
+            style.align = self.__retrieve_align_from_data(col_dp, value_dp)
+
+        if style.padding is None:
+            style.padding = self._get_padding_len(col_dp, value_dp)
+
+        return style
+
+    def _get_col_style(self, col_idx: int) -> Style:
+        try:
+            style = self.column_styles[col_idx]
+        except (TypeError, IndexError, KeyError):
+            pass
+        else:
+            if style:
+                return style
+
+        return self.default_style
+
+    def _get_align(self, col_idx: int, default_align: Align) -> Align:
+        align = self._get_col_style(col_idx).align
+
+        if align is None:
+            return default_align
+
+        if align == Align.AUTO:
+            return default_align
+
+        return align
+
+    def __retrieve_align_from_data(
+        self, col_dp: ColumnDataProperty, value_dp: DataProperty
+    ) -> Align:
+        if col_dp.typecode == Typecode.STRING and (
+            value_dp.typecode in (Typecode.INTEGER, Typecode.REAL_NUMBER)
+            or value_dp.typecode == Typecode.STRING
+            and value_dp.is_include_ansi_escape
+        ):
+            return value_dp.align
+
+        return col_dp.align
+
+    def _verify_property(self) -> None:
+        self._verify_style_filter_kwargs()
+        self._verify_table_name()
+        self._verify_stream()
+
+        if all(
+            [
+                typepy.is_empty_sequence(self.headers),
+                typepy.is_empty_sequence(self.value_matrix),
+                typepy.is_empty_sequence(self._table_value_dp_matrix),
+            ]
+        ):
+            raise EmptyTableDataError()
+
+        self._verify_header()
+        try:
+            self._verify_value_matrix()
+        except EmptyValueError:
+            pass
+
+    def __set_value_matrix(self, value_matrix: Sequence) -> None:
+        self.__value_matrix_org = value_matrix
+
+    def __set_type_hints(self, type_hints: Sequence[Union[str, TypeHint]]) -> None:
+        self._dp_extractor.column_type_hints = type_hints
+
+    def _verify_style_filter_kwargs(self) -> None:
+        for checker in self._check_style_filter_kwargs_funcs:
+            checker(**self.style_filter_kwargs)
+
+    def _verify_table_name(self) -> None:
+        if all([self._is_require_table_name, typepy.is_null_string(self.table_name)]):
+            raise EmptyTableNameError(
+                "table_name must be a string, with at least one or more character."
+            )
+
+    def _verify_stream(self) -> None:
+        if self.stream is None:
+            raise OSError("null output stream")
+
+    def _verify_header(self) -> None:
+        if self._is_require_header and not self._use_default_header:
+            self._validate_empty_header()
+
+    def _validate_empty_header(self) -> None:
+        """
+        Raises:
+            ValueError: If the |headers| is empty.
+        """
+
+        if typepy.is_empty_sequence(self.headers):
+            raise ValueError("headers expected to have one or more header names")
+
+    def _verify_value_matrix(self) -> None:
+        if typepy.is_empty_sequence(self.value_matrix):
+            raise EmptyValueError()
+
+    def _create_styler(self, writer: "AbstractTableWriter") -> StylerInterface:
+        from ..style._styler import NullStyler
+
+        return NullStyler(writer)
+
+    def _preprocess_table_dp(self) -> None:
+        if self._is_complete_table_dp_preprocess:
+            return
+
+        self._logger.logger.debug("_preprocess_table_dp")
+
+        if typepy.is_empty_sequence(self.headers) and self._use_default_header:
+            self.headers = [
+                convert_idx_to_alphabet(col_idx)
+                for col_idx in range(len(self.__value_matrix_org[0]))
+            ]
+
+        try:
+            self._table_value_dp_matrix = self._dp_extractor.to_dp_matrix(
+                to_value_matrix(self.headers, self.__value_matrix_org)
+            )
+        except TypeError as e:
+            self._logger.logger.debug(to_error_message(e))
+            self._table_value_dp_matrix = []
+
+        self._column_dp_list = self._dp_extractor.to_column_dp_list(
+            self._table_value_dp_matrix, self._column_dp_list
+        )
+
+        self._is_complete_table_dp_preprocess = True
+
+    def _fetch_style(self, row: int, col_dp: ColumnDataProperty, value_dp: DataProperty) -> Style:
+        default_style = self._get_col_style(col_dp.column_index)
+        return self._fetch_style_from_filter(row, col_dp, value_dp, default_style)
+
+    def _preprocess_table_property(self) -> None:
+        if self._is_complete_table_property_preprocess:
+            return
+
+        self._logger.logger.debug("_preprocess_table_property")
+
+        if self._iter_count == 1:
+            for column_dp in self._column_dp_list:
+                column_dp.extend_width(int(math.ceil(column_dp.ascii_char_width * 0.25)))
+
+        header_dp_list = self._dp_extractor.to_header_dp_list()
+        if not header_dp_list:
+            return
+
+        for column_dp in self._column_dp_list:
+            style = self._get_col_style(column_dp.column_index)
+            header_style = self._fetch_style(
+                HEADER_ROW, column_dp, header_dp_list[column_dp.column_index]
+            )
+            body_width = self._styler.get_additional_char_width(style)
+            header_width = self._styler.get_additional_char_width(header_style)
+            column_dp.extend_body_width(max(body_width, header_width))
+
+        self._is_complete_table_property_preprocess = True
+
+    def _preprocess_header(self) -> None:
+        if self._is_complete_header_preprocess:
+            return
+
+        self._logger.logger.debug("_preprocess_header")
+
+        self._table_headers = [
+            self._to_header_item(col_dp, header_dp)
+            for col_dp, header_dp in zip(
+                self._column_dp_list, self._dp_extractor.to_header_dp_list()
+            )
+        ]
+
+        self._is_complete_header_preprocess = True
+
+    def _preprocess_value_matrix(self) -> None:
+        if self._is_complete_value_matrix_preprocess:
+            return
+
+        self._logger.logger.debug(
+            f"_preprocess_value_matrix: value-rows={len(self._table_value_dp_matrix)}"
+        )
+
+        self._table_value_matrix = [
+            [
+                self._to_row_item(row_idx, col_dp, value_dp)
+                for col_dp, value_dp in zip(self._column_dp_list, value_dp_list)
+            ]
+            for row_idx, value_dp_list in enumerate(self._table_value_dp_matrix)
+        ]
+
+        self._is_complete_value_matrix_preprocess = True
+
+    def _preprocess(self) -> None:
+        self._preprocess_table_dp()
+        self._preprocess_table_property()
+        self._preprocess_header()
+        self._preprocess_value_matrix()
+
+    def _clear_preprocess(self) -> None:
+        self.__clear_preprocess()
+
+    def __clear_preprocess(self) -> None:
+        self.__clear_preprocess_status()
+        self.__clear_preprocess_data()

venv/lib/python3.10/site-packages/pytablewriter/writer/binary/__init__.py

@@ -0,0 +1,11 @@
+from ._excel import ExcelXlsTableWriter, ExcelXlsxTableWriter
+from ._pandas import PandasDataFramePickleWriter
+from ._sqlite import SqliteTableWriter
+
+
+__all__ = (
+    "ExcelXlsTableWriter",
+    "ExcelXlsxTableWriter",
+    "PandasDataFramePickleWriter",
+    "SqliteTableWriter",
+)

venv/lib/python3.10/site-packages/pytablewriter/writer/binary/_excel.py

@@ -0,0 +1,501 @@
+import abc
+import copy
+import warnings
+from typing import IO, TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union, cast
+
+import dataproperty
+import typepy
+from dataproperty import DataProperty
+from tabledata import TableData
+from typepy import Integer
+
+from .._common import import_error_msg_template
+from ._excel_workbook import ExcelWorkbookInterface, ExcelWorkbookXls, ExcelWorkbookXlsx
+from ._interface import AbstractBinaryTableWriter
+
+
+if TYPE_CHECKING:
+    from xlwt import XFStyle
+
+
+class ExcelTableWriter(AbstractBinaryTableWriter, metaclass=abc.ABCMeta):
+    """
+    An abstract class of a table writer for Excel file format.
+    """
+
+    FORMAT_NAME = "excel"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    @property
+    def workbook(self) -> Optional[ExcelWorkbookInterface]:
+        return self._workbook
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self._workbook: Optional[ExcelWorkbookInterface] = None
+
+        self._dp_extractor.type_value_map = {
+            typepy.Typecode.INFINITY: "Inf",
+            typepy.Typecode.NAN: "NaN",
+        }
+
+        self._first_header_row = 0
+        self._last_header_row = self.first_header_row
+        self._first_data_row = self.last_header_row + 1
+        self._first_data_col = 0
+        self._last_data_row: Optional[int] = None
+        self._last_data_col: Optional[int] = None
+
+        self._current_data_row = self._first_data_row
+
+        self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
+        self._quoting_flags[typepy.Typecode.DATETIME] = True
+
+    @property
+    def first_header_row(self) -> int:
+        """int: Index of the first row of the header.
+
+        .. note:: |excel_attr|
+        """
+
+        return self._first_header_row
+
+    @property
+    def last_header_row(self) -> int:
+        """int: Index of the last row of the header.
+
+        .. note:: |excel_attr|
+        """
+
+        return self._last_header_row
+
+    @property
+    def first_data_row(self) -> int:
+        """int: Index of the first row of the data (table body).
+
+        .. note:: |excel_attr|
+        """
+
+        return self._first_data_row
+
+    @property
+    def last_data_row(self) -> Optional[int]:
+        """int: Index of the last row of the data (table body).
+
+        .. note:: |excel_attr|
+        """
+
+        return self._last_data_row
+
+    @property
+    def first_data_col(self) -> int:
+        """int: Index of the first column of the table.
+
+        .. note:: |excel_attr|
+        """
+
+        return self._first_data_col
+
+    @property
+    def last_data_col(self) -> Optional[int]:
+        """int: Index of the last column of the table.
+
+        .. note:: |excel_attr|
+        """
+
+        return self._last_data_col
+
+    def is_opened(self) -> bool:
+        return self.workbook is not None
+
+    def open(self, file_path: str) -> None:
+        """
+        Open an Excel workbook file.
+
+        :param str file_path: Excel workbook file path to open.
+        """
+
+        if self.workbook and self.workbook.file_path == file_path:
+            self._logger.logger.debug(f"workbook already opened: {self.workbook.file_path}")
+            return
+
+        self.close()
+        self._open(file_path)
+
+    @abc.abstractmethod
+    def _open(self, workbook_path: str) -> None:  # pragma: no cover
+        pass
+
+    def close(self) -> None:
+        """
+        Close the current workbook.
+        """
+
+        if self.is_opened():
+            self.workbook.close()  # type: ignore
+            self._workbook = None
+
+    def from_tabledata(self, value: TableData, is_overwrite_table_name: bool = True) -> None:
+        """
+        Set following attributes from |TableData|
+
+        - :py:attr:`~.table_name`.
+        - :py:attr:`~.headers`.
+        - :py:attr:`~.value_matrix`.
+
+        And create worksheet named from :py:attr:`~.table_name` ABC
+        if not existed yet.
+
+        :param tabledata.TableData value: Input table data.
+        """
+
+        super().from_tabledata(value)
+
+        if self.is_opened():
+            self.make_worksheet(self.table_name)
+
+    def make_worksheet(self, sheet_name: Optional[str] = None) -> None:
+        """Make a worksheet to the current workbook.
+
+        Args:
+            sheet_name (str):
+                Name of the worksheet to create. The name will be automatically generated
+                (like ``"Sheet1"``) if the ``sheet_name`` is empty.
+        """
+
+        if sheet_name is None:
+            sheet_name = self.table_name
+        if not sheet_name:
+            sheet_name = ""
+
+        self._stream = self.workbook.add_worksheet(sheet_name)  # type: ignore
+        self._current_data_row = self._first_data_row
+
+    def dump(self, output: Union[str, IO], close_after_write: bool = True, **kwargs: Any) -> None:
+        """Write a worksheet to the current workbook.
+
+        Args:
+            output (str):
+                Path to the workbook file to write.
+            close_after_write (bool, optional):
+                Close the workbook after write.
+                Defaults to |True|.
+        """
+
+        if not isinstance(output, str):
+            raise TypeError(f"output must be a str: actual={type(output)}")
+
+        self.open(output)
+        try:
+            self.make_worksheet(self.table_name)
+            self.write_table(**kwargs)
+        finally:
+            if close_after_write:
+                self.close()
+
+    @abc.abstractmethod
+    def _write_header(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def _write_cell(self, row: int, col: int, value_dp: DataProperty) -> None:
+        pass
+
+    def _write_table(self, **kwargs: Any) -> None:
+        self._preprocess_table_dp()
+        self._preprocess_table_property()
+        self._write_header()
+        self._write_value_matrix()
+        self._postprocess()
+
+    def _write_value_matrix(self) -> None:
+        for value_dp_list in self._table_value_dp_matrix:
+            for col_idx, value_dp in enumerate(value_dp_list):
+                self._write_cell(self._current_data_row, col_idx, value_dp)
+
+            self._current_data_row += 1
+
+    def _get_last_column(self) -> int:
+        if typepy.is_not_empty_sequence(self.headers):
+            return len(self.headers) - 1
+
+        if typepy.is_not_empty_sequence(self.value_matrix):
+            return len(self.value_matrix[0]) - 1
+
+        raise ValueError("data not found")
+
+    def _postprocess(self) -> None:
+        self._last_data_row = self._current_data_row
+        self._last_data_col = self._get_last_column()
+
+
+class ExcelXlsTableWriter(ExcelTableWriter):
+    """
+    A table writer class for Excel file format: ``.xls`` (older or equal to Office 2003).
+
+    ``xlwt`` package required to use this class.
+
+    .. py:method:: write_table()
+
+        Write a table to the current opened worksheet.
+
+        :raises IOError: If failed to write data to the worksheet.
+
+        .. note::
+            Specific values in the tabular data are converted when writing:
+
+            - |None|: written as an empty string
+            - |inf|: written as ``Inf``
+            - |nan|: written as ``NaN``
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.__col_style_table: Dict[int, Any] = {}
+
+    def _open(self, workbook_path: str) -> None:
+        self._workbook = ExcelWorkbookXls(workbook_path)
+
+    def _write_header(self) -> None:
+        if not self.is_write_header or typepy.is_empty_sequence(self.headers):
+            return
+
+        for col, value in enumerate(self.headers):
+            self.stream.write(self.first_header_row, col, value)
+
+    def _write_cell(self, row: int, col: int, value_dp: DataProperty) -> None:
+        if value_dp.typecode in [typepy.Typecode.REAL_NUMBER]:
+            try:
+                cell_style = self.__get_cell_style(col)
+            except ValueError:
+                pass
+            else:
+                self.stream.write(row, col, value_dp.data, cell_style)
+                return
+
+        self.stream.write(row, col, value_dp.data)
+
+    def _postprocess(self) -> None:
+        super()._postprocess()
+
+        self.__col_style_table = {}
+
+    def __get_cell_style(self, col: int) -> "XFStyle":
+        try:
+            import xlwt
+        except ImportError:
+            warnings.warn(import_error_msg_template.format("excel"))
+            raise
+
+        if col in self.__col_style_table:
+            return self.__col_style_table.get(col)
+
+        try:
+            col_dp = self._column_dp_list[col]
+        except KeyError:
+            return {}
+
+        if col_dp.typecode not in [typepy.Typecode.REAL_NUMBER]:
+            raise ValueError()
+
+        if not Integer(col_dp.minmax_decimal_places.max_value).is_type():
+            raise ValueError()
+
+        float_digit = col_dp.minmax_decimal_places.max_value
+        if float_digit <= 0:
+            raise ValueError()
+
+        num_format_str = "#,{:s}0.{:s}".format("#" * int(float_digit), "0" * int(float_digit))
+        cell_style = xlwt.easyxf(num_format_str=num_format_str)
+        self.__col_style_table[col] = cell_style
+
+        return cell_style
+
+
+class ExcelXlsxTableWriter(ExcelTableWriter):
+    """
+    A table writer class for Excel file format: ``.xlsx`` (newer or equal to Office 2007).
+
+    .. py:method:: write_table()
+
+        Write a table to the current opened worksheet.
+
+        :raises IOError: If failed to write data to the worksheet.
+
+        Examples:
+            :ref:`example-excel-table-writer`
+
+        .. note::
+            Specific values in the tabular data are converted when writing:
+
+            - |None|: written as an empty string
+            - |inf|: written as ``Inf``
+            - |nan|: written as ``NaN``
+    """
+
+    MAX_CELL_WIDTH: ClassVar[int] = 60
+
+    class TableFormat:
+        HEADER = "header"
+        CELL = "cell"
+        NAN = "nan"
+
+    class Default:
+        FONT_NAME: ClassVar[str] = "MS Gothic"
+        FONT_SIZE: ClassVar[int] = 9
+
+        CELL_FORMAT: Dict[str, Union[int, str, bool]] = {
+            "font_name": FONT_NAME,
+            "font_size": FONT_SIZE,
+            "align": "top",
+            "text_wrap": True,
+            "top": 1,
+            "left": 1,
+            "bottom": 1,
+            "right": 1,
+        }
+        HEADER_FORMAT: Dict[str, Union[int, str, bool]] = {
+            "font_name": FONT_NAME,
+            "font_size": FONT_SIZE,
+            "bg_color": "#DFDFFF",
+            "bold": True,
+            "left": 1,
+            "right": 1,
+        }
+        NAN_FORMAT: Dict[str, Union[int, str, bool]] = {
+            "font_name": FONT_NAME,
+            "font_size": FONT_SIZE,
+            "font_color": "silver",
+            "top": 1,
+            "left": 1,
+            "bottom": 1,
+            "right": 1,
+        }
+
+    @property
+    def __nan_format_property(self) -> Dict[str, Union[int, str, bool]]:
+        return self.format_table.get(self.TableFormat.NAN, self.default_format)
+
+    @property
+    def __cell_format_property(self) -> Dict[str, Union[int, str, bool]]:
+        return self.format_table.get(self.TableFormat.CELL, self.default_format)
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.default_format = self.Default.CELL_FORMAT
+        self.format_table = {
+            self.TableFormat.CELL: self.Default.CELL_FORMAT,
+            self.TableFormat.HEADER: self.Default.HEADER_FORMAT,
+            self.TableFormat.NAN: self.Default.NAN_FORMAT,
+        }
+
+        self.__col_cell_format_cache: Dict[int, Any] = {}
+        self.__col_numprops_table: Dict[int, Dict[str, str]] = {}
+
+    def _open(self, workbook_path: str) -> None:
+        self._workbook = ExcelWorkbookXlsx(workbook_path)
+
+    def _write_header(self) -> None:
+        if not self.is_write_header or typepy.is_empty_sequence(self.headers):
+            return
+
+        header_format_props = self.format_table.get(self.TableFormat.HEADER, self.default_format)
+        header_format = self.__add_format(header_format_props)
+
+        self.stream.write_row(
+            row=self.first_header_row, col=0, data=self.headers, cell_format=header_format
+        )
+        for row in range(self.first_header_row, self.last_header_row):
+            self.stream.write_row(
+                row=row, col=0, data=[""] * len(self.headers), cell_format=header_format
+            )
+
+    def _write_cell(self, row: int, col: int, value_dp: DataProperty) -> None:
+        base_props = dict(self.__cell_format_property)
+        format_key = f"{col:d}_{value_dp.typecode.name:s}"
+
+        if value_dp.typecode in [typepy.Typecode.INTEGER, typepy.Typecode.REAL_NUMBER]:
+            num_props = self.__get_number_property(col)
+            base_props.update(num_props)
+            cell_format = self.__get_cell_format(format_key, base_props)
+
+            try:
+                self.stream.write_number(row, col, float(value_dp.data), cell_format)
+                return
+            except TypeError:
+                pass
+
+        if value_dp.typecode is typepy.Typecode.NAN:
+            base_props = dict(self.__nan_format_property)
+
+        cell_format = self.__get_cell_format(format_key, base_props)
+        self.stream.write(row, col, value_dp.data, cell_format)
+
+    def __get_number_property(self, col: int) -> Dict[str, str]:
+        if col in self.__col_numprops_table:
+            return self.__col_numprops_table[col]
+
+        try:
+            col_dp = self._column_dp_list[col]
+        except KeyError:
+            return {}
+
+        if col_dp.typecode not in [typepy.Typecode.INTEGER, typepy.Typecode.REAL_NUMBER]:
+            return {}
+
+        num_props = {}
+        if Integer(col_dp.minmax_decimal_places.max_value).is_type():
+            float_digit = col_dp.minmax_decimal_places.max_value
+            if float_digit > 0:
+                num_props = {"num_format": "0.{:s}".format("0" * int(float_digit))}
+
+        self.__col_numprops_table[col] = num_props
+
+        return num_props
+
+    def __get_cell_format(self, format_key, cell_props) -> Dict:  # type: ignore
+        cell_format = self.__col_cell_format_cache.get(format_key)
+        if cell_format is not None:
+            return cell_format
+
+        # cache miss
+        cell_format = self.__add_format(cell_props)
+        self.__col_cell_format_cache[format_key] = cell_format
+
+        return cell_format
+
+    def __add_format(self, dict_property):  # type: ignore
+        assert self.workbook
+        return self.workbook.workbook.add_format(dict_property)
+
+    def __set_cell_width(self) -> None:
+        font_size = cast(int, self.__cell_format_property.get("font_size"))
+
+        if not Integer(font_size).is_type():
+            return
+
+        for col_idx, col_dp in enumerate(self._column_dp_list):
+            width = min(col_dp.ascii_char_width, self.MAX_CELL_WIDTH) * (font_size / 10.0) + 2
+            self.stream.set_column(col_idx, col_idx, width=width)
+
+    def _preprocess_table_property(self) -> None:
+        super()._preprocess_table_property()
+
+        self.__set_cell_width()
+
+    def _postprocess(self) -> None:
+        super()._postprocess()
+
+        self.stream.autofilter(
+            self.last_header_row, self.first_data_col, self.last_data_row, self.last_data_col
+        )
+        self.stream.freeze_panes(self.first_data_row, self.first_data_col)
+
+        self.__col_cell_format_cache = {}
+        self.__col_numprops_table = {}

venv/lib/python3.10/site-packages/pytablewriter/writer/binary/_excel_workbook.py

@@ -0,0 +1,139 @@
+import abc
+import warnings
+from typing import Any, Dict, Optional
+
+import typepy
+
+from ..._logger import logger
+from ...sanitizer import sanitize_excel_sheet_name
+from .._common import import_error_msg_template
+from .._msgfy import to_error_message
+
+
+class ExcelWorkbookInterface(metaclass=abc.ABCMeta):
+    @abc.abstractproperty
+    def workbook(self) -> Any:  # pragma: no cover
+        pass
+
+    @abc.abstractproperty
+    def file_path(self) -> Optional[str]:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def open(self, file_path: str) -> None:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def close(self) -> None:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def add_worksheet(self, worksheet_name: Optional[str]) -> Any:  # pragma: no cover
+        pass
+
+
+class ExcelWorkbook(ExcelWorkbookInterface):
+    @property
+    def workbook(self) -> Any:
+        return self._workbook
+
+    @property
+    def file_path(self) -> Optional[str]:
+        return self._file_path
+
+    def _clear(self) -> None:
+        self._workbook = None
+        self._file_path: Optional[str] = None
+        self._worksheet_table: Dict[str, Any] = {}
+
+    def __init__(self, file_path: str) -> None:
+        self._clear()
+        self._file_path = file_path
+
+    def __del__(self) -> None:
+        self.close()
+
+
+class ExcelWorkbookXls(ExcelWorkbook):
+    def __init__(self, file_path: str) -> None:
+        super().__init__(file_path)
+
+        self.open(file_path)
+
+    def open(self, file_path: str) -> None:
+        try:
+            import xlwt
+        except ImportError:
+            warnings.warn(import_error_msg_template.format("excel"))
+            raise
+
+        self._workbook = xlwt.Workbook()
+
+    def close(self) -> None:
+        if self.workbook is None:
+            return
+
+        try:
+            self.workbook.save(self._file_path)
+        except IndexError as e:
+            logger.debug(to_error_message(e))
+
+        self._clear()
+
+    def add_worksheet(self, worksheet_name: Optional[str]) -> Any:
+        if typepy.is_not_null_string(worksheet_name):
+            assert worksheet_name
+            worksheet_name = sanitize_excel_sheet_name(worksheet_name)
+            if worksheet_name in self._worksheet_table:
+                # the work sheet is already exists
+                return self._worksheet_table.get(worksheet_name)
+        else:
+            sheet_id = 1
+            while True:
+                worksheet_name = f"Sheet{sheet_id:d}"
+                if worksheet_name not in self._worksheet_table:
+                    break
+                sheet_id += 1
+
+        worksheet = self.workbook.add_sheet(worksheet_name)
+        self._worksheet_table[worksheet.get_name()] = worksheet
+
+        return worksheet
+
+
+class ExcelWorkbookXlsx(ExcelWorkbook):
+    def __init__(self, file_path: str) -> None:
+        super().__init__(file_path)
+
+        self.open(file_path)
+
+    def open(self, file_path: str) -> None:
+        try:
+            import xlsxwriter
+        except ImportError:
+            warnings.warn(import_error_msg_template.format("excel"))
+            raise
+
+        self._workbook = xlsxwriter.Workbook(file_path)
+
+    def close(self) -> None:
+        if self.workbook is None:
+            return
+
+        self._workbook.close()  # type: ignore
+        self._clear()
+
+    def add_worksheet(self, worksheet_name: Optional[str]) -> Any:
+        if typepy.is_not_null_string(worksheet_name):
+            assert worksheet_name
+            worksheet_name = sanitize_excel_sheet_name(worksheet_name)
+            if worksheet_name in self._worksheet_table:
+                # the work sheet is already exists
+                return self._worksheet_table.get(worksheet_name)
+        else:
+            worksheet_name = None
+
+        worksheet = self.workbook.add_worksheet(worksheet_name)
+        self._worksheet_table[worksheet.get_name()] = worksheet
+
+        return worksheet

venv/lib/python3.10/site-packages/pytablewriter/writer/binary/_interface.py

@@ -0,0 +1,58 @@
+import abc
+from typing import Any
+
+from .._table_writer import AbstractTableWriter
+
+
+class BinaryWriterInterface(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def is_opened(self) -> bool:  # pragma: no cover
+        pass
+
+    @abc.abstractmethod
+    def open(self, file_path: str) -> None:  # pragma: no cover
+        """
+        Open a file for output stream.
+
+        Args:
+            file_path (str): path to the file.
+        """
+
+
+class AbstractBinaryTableWriter(AbstractTableWriter, BinaryWriterInterface):
+    @property
+    def stream(self) -> Any:
+        return self._stream
+
+    @stream.setter
+    def stream(self, value: Any) -> None:
+        raise RuntimeError(
+            "cannot assign a stream to binary format writers. use open method instead."
+        )
+
+    @property
+    def support_split_write(self) -> bool:
+        return True
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+
+        self.table_name = kwargs.get("table_name", "")
+
+        self._stream = None
+
+    def __del__(self) -> None:
+        self.close()
+
+    def is_opened(self) -> bool:
+        return self.stream is not None
+
+    def dumps(self) -> str:
+        raise NotImplementedError("binary format writers did not support dumps method")
+
+    def _verify_stream(self) -> None:
+        if self.stream is None:
+            raise OSError("null output stream. required to open(file_path) first.")
+
+    def _write_value_row_separator(self) -> None:
+        pass

venv/lib/python3.10/site-packages/pytablewriter/writer/binary/_pandas.py

@@ -0,0 +1,99 @@
+from typing import IO, Any, Optional, Union
+
+import tabledata
+
+from ...error import EmptyValueError
+from ._interface import AbstractBinaryTableWriter
+
+
+class PandasDataFramePickleWriter(AbstractBinaryTableWriter):
+    """
+    A table writer class for pandas DataFrame pickle.
+
+    .. py:method:: write_table()
+
+        Write a table to a pandas DataFrame pickle file.
+    """
+
+    FORMAT_NAME = "pandas_pickle"
+
+    @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:
+        import copy
+
+        import dataproperty
+
+        super().__init__(**kwargs)
+
+        self.is_padding = False
+        self.is_formatting_float = False
+        self._use_default_header = True
+
+        self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
+
+        self.__filepath: Optional[str] = None
+
+    def is_opened(self) -> bool:
+        return self.__filepath is not None
+
+    def open(self, file_path: str) -> None:
+        self.__filepath = file_path
+
+    def close(self) -> None:
+        super().close()
+        self.__filepath = None
+
+    def dump(self, output: Union[str, IO], close_after_write: bool = True, **kwargs: Any) -> None:
+        """Write data to a DataFrame pickle file.
+
+        Args:
+            output (str): Path to an output DataFrame pickle file.
+        """
+
+        if not isinstance(output, str):
+            raise TypeError(f"output must be a str: actual={type(output)}")
+
+        self.open(output)
+        try:
+            self.write_table(**kwargs)
+        finally:
+            if close_after_write:
+                self.close()
+
+    def _verify_stream(self) -> None:
+        pass
+
+    def _write_table(self, **kwargs: Any) -> None:
+        if not self.is_opened():
+            self._logger.logger.error("required to open(file_path) first.")
+            return
+
+        try:
+            self._verify_value_matrix()
+        except EmptyValueError:
+            self._logger.logger.debug("no tabular data found")
+            return
+
+        self._preprocess()
+
+        table_data = tabledata.TableData(
+            self.table_name,
+            self.headers,
+            [
+                [value_dp.data for value_dp in value_dp_list]
+                for value_dp_list in self._table_value_dp_matrix
+            ],
+            type_hints=self.type_hints,
+            max_workers=self.max_workers,
+        )
+        table_data.as_dataframe().to_pickle(self.__filepath)
+
+    def _write_table_iter(self, **kwargs: Any) -> None:
+        self._write_table(**kwargs)

venv/lib/python3.10/site-packages/pytablewriter/writer/binary/_sqlite.py

@@ -0,0 +1,104 @@
+from os.path import abspath
+from typing import IO, Any, Union
+
+import tabledata
+
+from ...error import EmptyValueError
+from ._interface import AbstractBinaryTableWriter
+
+
+class SqliteTableWriter(AbstractBinaryTableWriter):
+    """
+    A table writer class for `SQLite <https://www.sqlite.org/index.html>`__ database.
+
+    .. py:method:: write_table()
+
+        Write a table to a `SQLite <https://www.sqlite.org/index.html>`__ database.
+
+        :raises pytablewriter.EmptyTableNameError:
+            If the |table_name| is empty.
+        :Example:
+            :ref:`example-sqlite-table-writer`
+    """
+
+    FORMAT_NAME = "sqlite"
+
+    @property
+    def format_name(self) -> str:
+        return self.FORMAT_NAME
+
+    def __init__(self, **kwargs: Any) -> None:
+        import copy
+
+        import dataproperty
+
+        super().__init__(**kwargs)
+
+        self.is_padding = False
+        self.is_formatting_float = False
+        self._use_default_header = True
+
+        self._is_require_table_name = True
+        self._is_require_header = True
+
+        self._quoting_flags = copy.deepcopy(dataproperty.NOT_QUOTING_FLAGS)
+
+    def open(self, file_path: str) -> None:
+        """
+        Open a SQLite database file.
+
+        :param str file_path: SQLite database file path to open.
+        """
+
+        from simplesqlite import SimpleSQLite
+
+        if self.is_opened():
+            if self.stream.database_path == abspath(file_path):
+                self._logger.logger.debug(f"database already opened: {self.stream.database_path}")
+                return
+
+            self.close()
+
+        self._stream = SimpleSQLite(file_path, "w", max_workers=self.max_workers)
+
+    def dump(self, output: Union[str, IO], close_after_write: bool = True, **kwargs: Any) -> None:
+        """Write data to the SQLite database file.
+
+        Args:
+            output (str):
+                path to the output SQLite database file.
+            close_after_write (bool, optional):
+                Close the output after write.
+                Defaults to |True|.
+        """
+
+        if not isinstance(output, str):
+            raise TypeError(f"output must be a str: actual={type(output)}")
+
+        self.open(output)
+        try:
+            self.write_table(**kwargs)
+        finally:
+            if close_after_write:
+                self.close()
+
+    def _write_table(self, **kwargs: Any) -> None:
+        try:
+            self._verify_value_matrix()
+        except EmptyValueError:
+            self._logger.logger.debug("no tabular data found")
+            return
+
+        self._preprocess()
+
+        table_data = tabledata.TableData(
+            self.table_name,
+            self.headers,
+            [
+                [value_dp.data for value_dp in value_dp_list]
+                for value_dp_list in self._table_value_dp_matrix
+            ],
+            type_hints=self.type_hints,
+            max_workers=self.max_workers,
+        )
+        self.stream.create_table_from_tabledata(table_data)

venv/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",
+)

venv/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)

venv/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()

venv/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

venv/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>")