brainstate 0.1.0.post20250212__py2.py3-none-any.whl → 0.1.0.post20250217__py2.py3-none-any.whl

brainstate/util/_pretty_table.py

@@ -0,0 +1,2900 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2009-2014, Luke Maurits <luke@maurits.id.au>
+# All rights reserved.
+# With contributions from:
+#  * Chris Clark
+#  * Klein Stephane
+#  * John Filleau
+#  * Vladimir Vrzić
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * The name of the author may not be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import annotations
+
+import io
+import re
+import warnings
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from enum import IntEnum
+from html.parser import HTMLParser
+from typing import TYPE_CHECKING, Any, Final, Literal, TypedDict, cast
+
+if TYPE_CHECKING:
+    from sqlite3 import Cursor
+
+    from _typeshed import SupportsRichComparison
+    from typing_extensions import Self, TypeAlias
+
+__all__ = [
+    "PrettyTable"
+]
+
+
+class HRuleStyle(IntEnum):
+    FRAME = 0
+    ALL = 1
+    NONE = 2
+    HEADER = 3
+
+
+class VRuleStyle(IntEnum):
+    FRAME = 0
+    ALL = 1
+    NONE = 2
+
+
+class TableStyle(IntEnum):
+    DEFAULT = 10
+    MSWORD_FRIENDLY = 11
+    PLAIN_COLUMNS = 12
+    MARKDOWN = 13
+    ORGMODE = 14
+    DOUBLE_BORDER = 15
+    SINGLE_BORDER = 16
+    RANDOM = 20
+
+
+# keep for backwards compatibility
+_DEPRECATED_FRAME: Final = 0
+_DEPRECATED_ALL: Final = 1
+_DEPRECATED_NONE: Final = 2
+_DEPRECATED_HEADER: Final = 3
+_DEPRECATED_DEFAULT: Final = TableStyle.DEFAULT
+_DEPRECATED_MSWORD_FRIENDLY: Final = TableStyle.MSWORD_FRIENDLY
+_DEPRECATED_PLAIN_COLUMNS: Final = TableStyle.PLAIN_COLUMNS
+_DEPRECATED_MARKDOWN: Final = TableStyle.MARKDOWN
+_DEPRECATED_ORGMODE: Final = TableStyle.ORGMODE
+_DEPRECATED_DOUBLE_BORDER: Final = TableStyle.DOUBLE_BORDER
+_DEPRECATED_SINGLE_BORDER: Final = TableStyle.SINGLE_BORDER
+_DEPRECATED_RANDOM: Final = TableStyle.RANDOM
+# --------------------------------
+
+BASE_ALIGN_VALUE: Final = "base_align_value"
+
+RowType: TypeAlias = list[Any]
+AlignType: TypeAlias = Literal["l", "c", "r"]
+VAlignType: TypeAlias = Literal["t", "m", "b"]
+HeaderStyleType: TypeAlias = Literal["cap", "title", "upper", "lower", None]
+
+
+class OptionsType(TypedDict):
+    title: str | None
+    start: int
+    end: int | None
+    fields: Sequence[str | None] | None
+    header: bool
+    border: bool
+    preserve_internal_border: bool
+    sortby: str | None
+    reversesort: bool
+    sort_key: Callable[[RowType], SupportsRichComparison]
+    attributes: dict[str, str]
+    format: bool
+    hrules: HRuleStyle
+    vrules: VRuleStyle
+    int_format: str | dict[str, str] | None
+    float_format: str | dict[str, str] | None
+    custom_format: (
+        Callable[[str, Any], str] | dict[str, Callable[[str, Any], str]] | None
+    )
+    min_table_width: int | None
+    max_table_width: int | None
+    padding_width: int
+    left_padding_width: int | None
+    right_padding_width: int | None
+    vertical_char: str
+    horizontal_char: str
+    horizontal_align_char: str
+    junction_char: str
+    header_style: HeaderStyleType
+    xhtml: bool
+    print_empty: bool
+    oldsortslice: bool
+    top_junction_char: str
+    bottom_junction_char: str
+    right_junction_char: str
+    left_junction_char: str
+    top_right_junction_char: str
+    top_left_junction_char: str
+    bottom_right_junction_char: str
+    bottom_left_junction_char: str
+    align: dict[str, AlignType]
+    valign: dict[str, VAlignType]
+    min_width: int | dict[str, int] | None
+    max_width: int | dict[str, int] | None
+    none_format: str | dict[str, str | None] | None
+    escape_header: bool
+    escape_data: bool
+
+
+_re = re.compile(r"\033\[[0-9;]*m|\033\(B")
+
+
+def _get_size(text: str) -> tuple[int, int]:
+    lines = text.split("\n")
+    height = len(lines)
+    width = max(_str_block_width(line) for line in lines)
+    return width, height
+
+
+class PrettyTable:
+    __module__ = 'brainstate.util'
+
+    _xhtml: bool
+    _align: dict[str, AlignType]
+    _valign: dict[str, VAlignType]
+    _min_width: dict[str, int]
+    _max_width: dict[str, int]
+    _min_table_width: int | None
+    _max_table_width: int | None
+    _fields: Sequence[str | None] | None
+    _title: str | None
+    _start: int
+    _end: int | None
+    _sortby: str | None
+    _reversesort: bool
+    _sort_key: Callable[[RowType], SupportsRichComparison]
+    _header: bool
+    _header_style: HeaderStyleType
+    _border: bool
+    _preserve_internal_border: bool
+    _hrules: HRuleStyle
+    _vrules: VRuleStyle
+    _int_format: dict[str, str]
+    _float_format: dict[str, str]
+    _custom_format: dict[str, Callable[[str, Any], str]]
+    _padding_width: int
+    _left_padding_width: int | None
+    _right_padding_width: int | None
+    _vertical_char: str
+    _horizontal_char: str
+    _horizontal_align_char: str | None
+    _junction_char: str
+    _top_junction_char: str | None
+    _bottom_junction_char: str | None
+    _right_junction_char: str | None
+    _left_junction_char: str | None
+    _top_right_junction_char: str | None
+    _top_left_junction_char: str | None
+    _bottom_right_junction_char: str | None
+    _bottom_left_junction_char: str | None
+    _format: bool
+    _print_empty: bool
+    _oldsortslice: bool
+    _attributes: dict[str, str]
+    _escape_header: bool
+    _escape_data: bool
+    _style: TableStyle | None
+    orgmode: bool
+    _widths: list[int]
+    _hrule: str
+
+    def __init__(self, field_names: Sequence[str] | None = None, **kwargs) -> None:
+        """Return a new PrettyTable instance
+
+        Arguments:
+
+        encoding - Unicode encoding scheme used to decode any encoded input
+        title - optional table title
+        field_names - list or tuple of field names
+        fields - list or tuple of field names to include in displays
+        start - index of first data row to include in output
+        end - index of last data row to include in output PLUS ONE (list slice style)
+        header - print a header showing field names (True or False)
+        header_style - stylisation to apply to field names in header
+            ("cap", "title", "upper", "lower" or None)
+        border - print a border around the table (True or False)
+        preserve_internal_border - print a border inside the table even if
+            border is disabled (True or False)
+        hrules - controls printing of horizontal rules after rows.
+            Allowed values: HRuleStyle
+        vrules - controls printing of vertical rules between columns.
+            Allowed values: VRuleStyle
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
+        custom_format - controls formatting of any column using callable
+        min_table_width - minimum desired table width, in characters
+        max_table_width - maximum desired table width, in characters
+        min_width - minimum desired field width, in characters
+        max_width - maximum desired field width, in characters
+        padding_width - number of spaces on either side of column data
+            (only used if left and right paddings are None)
+        left_padding_width - number of spaces on left hand side of column data
+        right_padding_width - number of spaces on right hand side of column data
+        vertical_char - single character string used to draw vertical lines
+        horizontal_char - single character string used to draw horizontal lines
+        horizontal_align_char - single character string used to indicate alignment
+        junction_char - single character string used to draw line junctions
+        top_junction_char - single character string used to draw top line junctions
+        bottom_junction_char -
+            single character string used to draw bottom line junctions
+        right_junction_char - single character string used to draw right line junctions
+        left_junction_char - single character string used to draw left line junctions
+        top_right_junction_char -
+            single character string used to draw top-right line junctions
+        top_left_junction_char -
+            single character string used to draw top-left line junctions
+        bottom_right_junction_char -
+            single character string used to draw bottom-right line junctions
+        bottom_left_junction_char -
+            single character string used to draw bottom-left line junctions
+        sortby - name of field to sort rows by
+        sort_key - sorting key function, applied to data points before sorting
+        align - default align for each column (None, "l", "c" or "r")
+        valign - default valign for each row (None, "t", "m" or "b")
+        reversesort - True or False to sort in descending or ascending order
+        oldsortslice - Slice rows before sorting in the "old style" """
+
+        self.encoding = kwargs.get("encoding", "UTF-8")
+
+        # Data
+        self._field_names: list[str] = []
+        self._rows: list[RowType] = []
+        self._dividers: list[bool] = []
+        self.align = {}
+        self.valign = {}
+        self.max_width = {}
+        self.min_width = {}
+        self.int_format = {}
+        self.float_format = {}
+        self.custom_format = {}
+        self._style = None
+
+        # Options
+        self._options = [
+            "title",
+            "start",
+            "end",
+            "fields",
+            "header",
+            "border",
+            "preserve_internal_border",
+            "sortby",
+            "reversesort",
+            "sort_key",
+            "attributes",
+            "format",
+            "hrules",
+            "vrules",
+            "int_format",
+            "float_format",
+            "custom_format",
+            "min_table_width",
+            "max_table_width",
+            "padding_width",
+            "left_padding_width",
+            "right_padding_width",
+            "vertical_char",
+            "horizontal_char",
+            "horizontal_align_char",
+            "junction_char",
+            "header_style",
+            "xhtml",
+            "print_empty",
+            "oldsortslice",
+            "top_junction_char",
+            "bottom_junction_char",
+            "right_junction_char",
+            "left_junction_char",
+            "top_right_junction_char",
+            "top_left_junction_char",
+            "bottom_right_junction_char",
+            "bottom_left_junction_char",
+            "align",
+            "valign",
+            "max_width",
+            "min_width",
+            "none_format",
+            "escape_header",
+            "escape_data",
+        ]
+
+        self._none_format: dict[str, str | None] = {}
+        self._kwargs = {}
+        if field_names:
+            self.field_names = field_names
+        else:
+            self._widths: list[int] = []
+
+        for option in self._options:
+            if option in kwargs:
+                self._validate_option(option, kwargs[option])
+                self._kwargs[option] = kwargs[option]
+            else:
+                kwargs[option] = None
+                self._kwargs[option] = None
+
+        self._title = kwargs["title"] or None
+        self._start = kwargs["start"] or 0
+        self._end = kwargs["end"] or None
+        self._fields = kwargs["fields"] or None
+
+        if kwargs["header"] in (True, False):
+            self._header = kwargs["header"]
+        else:
+            self._header = True
+        self._header_style = kwargs["header_style"] or None
+        if kwargs["border"] in (True, False):
+            self._border = kwargs["border"]
+        else:
+            self._border = True
+        if kwargs["preserve_internal_border"] in (True, False):
+            self._preserve_internal_border = kwargs["preserve_internal_border"]
+        else:
+            self._preserve_internal_border = False
+        self._hrules = kwargs["hrules"] or HRuleStyle.FRAME
+        self._vrules = kwargs["vrules"] or VRuleStyle.ALL
+
+        self._sortby = kwargs["sortby"] or None
+        if kwargs["reversesort"] in (True, False):
+            self._reversesort = kwargs["reversesort"]
+        else:
+            self._reversesort = False
+        self._sort_key = kwargs["sort_key"] or (lambda x: x)
+
+        if kwargs["escape_data"] in (True, False):
+            self._escape_data = kwargs["escape_data"]
+        else:
+            self._escape_data = True
+        if kwargs["escape_header"] in (True, False):
+            self._escape_header = kwargs["escape_header"]
+        else:
+            self._escape_header = True
+
+        self._column_specific_args()
+
+        self._min_table_width = kwargs["min_table_width"] or None
+        self._max_table_width = kwargs["max_table_width"] or None
+        if kwargs["padding_width"] is None:
+            self._padding_width = 1
+        else:
+            self._padding_width = kwargs["padding_width"]
+        self._left_padding_width = kwargs["left_padding_width"] or None
+        self._right_padding_width = kwargs["right_padding_width"] or None
+
+        self._vertical_char = kwargs["vertical_char"] or "|"
+        self._horizontal_char = kwargs["horizontal_char"] or "-"
+        self._horizontal_align_char = kwargs["horizontal_align_char"]
+        self._junction_char = kwargs["junction_char"] or "+"
+        self._top_junction_char = kwargs["top_junction_char"]
+        self._bottom_junction_char = kwargs["bottom_junction_char"]
+        self._right_junction_char = kwargs["right_junction_char"]
+        self._left_junction_char = kwargs["left_junction_char"]
+        self._top_right_junction_char = kwargs["top_right_junction_char"]
+        self._top_left_junction_char = kwargs["top_left_junction_char"]
+        self._bottom_right_junction_char = kwargs["bottom_right_junction_char"]
+        self._bottom_left_junction_char = kwargs["bottom_left_junction_char"]
+
+        if kwargs["print_empty"] in (True, False):
+            self._print_empty = kwargs["print_empty"]
+        else:
+            self._print_empty = True
+        if kwargs["oldsortslice"] in (True, False):
+            self._oldsortslice = kwargs["oldsortslice"]
+        else:
+            self._oldsortslice = False
+        self._format = kwargs["format"] or False
+        self._xhtml = kwargs["xhtml"] or False
+        self._attributes = kwargs["attributes"] or {}
+
+    def _column_specific_args(self):
+        # Column specific arguments, use property.setters
+        for attr in (
+            "align",
+            "valign",
+            "max_width",
+            "min_width",
+            "int_format",
+            "float_format",
+            "custom_format",
+            "none_format",
+        ):
+            setattr(
+                self, attr, (self._kwargs[attr] or {}) if attr in self._kwargs else {}
+            )
+
+    def _justify(self, text: str, width: int, align: AlignType) -> str:
+        excess = width - _str_block_width(text)
+        if align == "l":
+            return text + excess * " "
+        elif align == "r":
+            return excess * " " + text
+        else:
+            if excess % 2:
+                # Uneven padding
+                # Put more space on right if text is of odd length...
+                if _str_block_width(text) % 2:
+                    return (excess // 2) * " " + text + (excess // 2 + 1) * " "
+                # and more space on left if text is of even length
+                else:
+                    return (excess // 2 + 1) * " " + text + (excess // 2) * " "
+                # Why distribute extra space this way?  To match the behaviour of
+                # the inbuilt str.center() method.
+            else:
+                # Equal padding on either side
+                return (excess // 2) * " " + text + (excess // 2) * " "
+
+    def __getattr__(self, name):
+        if name == "rowcount":
+            return len(self._rows)
+        elif name == "colcount":
+            if self._field_names:
+                return len(self._field_names)
+            elif self._rows:
+                return len(self._rows[0])
+            else:
+                return 0
+        else:
+            raise AttributeError(name)
+
+    def __getitem__(self, index: int | slice) -> PrettyTable:
+        new = PrettyTable()
+        new.field_names = self.field_names
+        for attr in self._options:
+            setattr(new, "_" + attr, getattr(self, "_" + attr))
+        setattr(new, "_align", getattr(self, "_align"))
+        if isinstance(index, slice):
+            for row in self._rows[index]:
+                new.add_row(row)
+        elif isinstance(index, int):
+            new.add_row(self._rows[index])
+        else:
+            msg = f"Index {index} is invalid, must be an integer or slice"
+            raise IndexError(msg)
+        return new
+
+    def __str__(self) -> str:
+        return self.get_string()
+
+    def __repr__(self) -> str:
+        return self.get_string()
+
+    def _repr_html_(self) -> str:
+        """
+        Returns get_html_string value by default
+        as the repr call in Jupyter notebook environment
+        """
+        return self.get_html_string()
+
+    ##############################
+    # ATTRIBUTE VALIDATORS       #
+    ##############################
+
+    # The method _validate_option is all that should be used elsewhere in the code base
+    # to validate options. It will call the appropriate validation method for that
+    # option. The individual validation methods should never need to be called directly
+    # (although nothing bad will happen if they *are*).
+    # Validation happens in TWO places.
+    # Firstly, in the property setters defined in the ATTRIBUTE MANAGEMENT section.
+    # Secondly, in the _get_options method, where keyword arguments are mixed with
+    # persistent settings
+
+    def _validate_option(self, option, val) -> None:
+        if option == "field_names":
+            self._validate_field_names(val)
+        elif option == "none_format":
+            self._validate_none_format(val)
+        elif option in (
+            "start",
+            "end",
+            "max_width",
+            "min_width",
+            "min_table_width",
+            "max_table_width",
+            "padding_width",
+            "left_padding_width",
+            "right_padding_width",
+        ):
+            self._validate_nonnegative_int(option, val)
+        elif option == "sortby":
+            self._validate_field_name(option, val)
+        elif option == "sort_key":
+            self._validate_function(option, val)
+        elif option == "hrules":
+            self._validate_hrules(option, val)
+        elif option == "vrules":
+            self._validate_vrules(option, val)
+        elif option == "fields":
+            self._validate_all_field_names(option, val)
+        elif option in (
+            "header",
+            "border",
+            "preserve_internal_border",
+            "reversesort",
+            "xhtml",
+            "format",
+            "print_empty",
+            "oldsortslice",
+            "escape_header",
+            "escape_data",
+        ):
+            self._validate_true_or_false(option, val)
+        elif option == "header_style":
+            self._validate_header_style(val)
+        elif option == "int_format":
+            self._validate_int_format(option, val)
+        elif option == "float_format":
+            self._validate_float_format(option, val)
+        elif option == "custom_format":
+            for k, formatter in val.items():
+                self._validate_function(f"{option}.{k}", formatter)
+        elif option in (
+            "vertical_char",
+            "horizontal_char",
+            "horizontal_align_char",
+            "junction_char",
+            "top_junction_char",
+            "bottom_junction_char",
+            "right_junction_char",
+            "left_junction_char",
+            "top_right_junction_char",
+            "top_left_junction_char",
+            "bottom_right_junction_char",
+            "bottom_left_junction_char",
+        ):
+            self._validate_single_char(option, val)
+        elif option == "attributes":
+            self._validate_attributes(option, val)
+
+    def _validate_field_names(self, val):
+        # Check for appropriate length
+        if self._field_names:
+            try:
+                assert len(val) == len(self._field_names)
+            except AssertionError:
+                msg = (
+                    "Field name list has incorrect number of values, "
+                    f"(actual) {len(val)}!={len(self._field_names)} (expected)"
+                )
+                raise ValueError(msg)
+        if self._rows:
+            try:
+                assert len(val) == len(self._rows[0])
+            except AssertionError:
+                msg = (
+                    "Field name list has incorrect number of values, "
+                    f"(actual) {len(val)}!={len(self._rows[0])} (expected)"
+                )
+                raise ValueError(msg)
+        # Check for uniqueness
+        try:
+            assert len(val) == len(set(val))
+        except AssertionError:
+            msg = "Field names must be unique"
+            raise ValueError(msg)
+
+    def _validate_none_format(self, val):
+        try:
+            if val is not None:
+                assert isinstance(val, str)
+        except AssertionError:
+            msg = "Replacement for None value must be a string if being supplied."
+            raise TypeError(msg)
+
+    def _validate_header_style(self, val):
+        try:
+            assert val in ("cap", "title", "upper", "lower", None)
+        except AssertionError:
+            msg = "Invalid header style, use cap, title, upper, lower or None"
+            raise ValueError(msg)
+
+    def _validate_align(self, val):
+        try:
+            assert val in ["l", "c", "r"]
+        except AssertionError:
+            msg = f"Alignment {val} is invalid, use l, c or r"
+            raise ValueError(msg)
+
+    def _validate_valign(self, val):
+        try:
+            assert val in ["t", "m", "b"]
+        except AssertionError:
+            msg = f"Alignment {val} is invalid, use t, m, b"
+            raise ValueError(msg)
+
+    def _validate_nonnegative_int(self, name, val):
+        try:
+            assert int(val) >= 0
+        except AssertionError:
+            msg = f"Invalid value for {name}: {val}"
+            raise ValueError(msg)
+
+    def _validate_true_or_false(self, name, val):
+        try:
+            assert val in (True, False)
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be True or False."
+            raise ValueError(msg)
+
+    def _validate_int_format(self, name, val):
+        if val == "":
+            return
+        try:
+            assert isinstance(val, str)
+            assert val.isdigit()
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be an integer format string."
+            raise ValueError(msg)
+
+    def _validate_float_format(self, name, val):
+        if val == "":
+            return
+        try:
+            assert isinstance(val, str)
+            assert "." in val
+            bits = val.split(".")
+            assert len(bits) <= 2
+            assert bits[0] == "" or bits[0].isdigit()
+            assert (
+                bits[1] == ""
+                or bits[1].isdigit()
+                or (bits[1][-1] == "f" and bits[1].rstrip("f").isdigit())
+            )
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be a float format string."
+            raise ValueError(msg)
+
+    def _validate_function(self, name, val):
+        try:
+            assert hasattr(val, "__call__")
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be a function."
+            raise ValueError(msg)
+
+    def _validate_hrules(self, name, val):
+        try:
+            assert val in list(HRuleStyle)
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be HRuleStyle."
+            raise ValueError(msg)
+
+    def _validate_vrules(self, name, val):
+        try:
+            assert val in list(VRuleStyle)
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be VRuleStyle."
+            raise ValueError(msg)
+
+    def _validate_field_name(self, name, val):
+        try:
+            assert (val in self._field_names) or (val is None)
+        except AssertionError:
+            msg = f"Invalid field name: {val}"
+            raise ValueError(msg)
+
+    def _validate_all_field_names(self, name, val):
+        try:
+            for x in val:
+                self._validate_field_name(name, x)
+        except AssertionError:
+            msg = "Fields must be a sequence of field names"
+            raise ValueError(msg)
+
+    def _validate_single_char(self, name, val):
+        try:
+            assert _str_block_width(val) == 1
+        except AssertionError:
+            msg = f"Invalid value for {name}. Must be a string of length 1."
+            raise ValueError(msg)
+
+    def _validate_attributes(self, name, val):
+        try:
+            assert isinstance(val, dict)
+        except AssertionError:
+            msg = "Attributes must be a dictionary of name/value pairs"
+            raise TypeError(msg)
+
+    ##############################
+    # ATTRIBUTE MANAGEMENT       #
+    ##############################
+    @property
+    def rows(self) -> list[RowType]:
+        return self._rows[:]
+
+    @property
+    def dividers(self) -> list[bool]:
+        return self._dividers[:]
+
+    @property
+    def xhtml(self) -> bool:
+        """Print <br/> tags if True, <br> tags if False"""
+        return self._xhtml
+
+    @xhtml.setter
+    def xhtml(self, val: bool) -> None:
+        self._validate_option("xhtml", val)
+        self._xhtml = val
+
+    @property
+    def none_format(self):
+        return self._none_format
+
+    @none_format.setter
+    def none_format(self, val):
+        if not self._field_names:
+            self._none_format = {}
+        elif val is None or (isinstance(val, dict) and len(val) == 0):
+            for field in self._field_names:
+                self._none_format[field] = None
+        else:
+            self._validate_none_format(val)
+            for field in self._field_names:
+                self._none_format[field] = val
+
+    @property
+    def field_names(self):
+        """List or tuple of field names
+
+        When setting field_names, if there are already field names the new list
+        of field names must be the same length. Columns are renamed and row data
+        remains unchanged."""
+        return self._field_names
+
+    @field_names.setter
+    def field_names(self, val) -> None:
+        val = [str(x) for x in val]
+        self._validate_option("field_names", val)
+        old_names = None
+        if self._field_names:
+            old_names = self._field_names[:]
+        self._field_names = val
+
+        self._column_specific_args()
+
+        if self._align and old_names:
+            for old_name, new_name in zip(old_names, val):
+                self._align[new_name] = self._align[old_name]
+            for old_name in old_names:
+                if old_name not in self._align:
+                    self._align.pop(old_name)
+        elif self._align:
+            for field_name in self._field_names:
+                self._align[field_name] = self._align[BASE_ALIGN_VALUE]
+        else:
+            self.align = "c"
+        if self._valign and old_names:
+            for old_name, new_name in zip(old_names, val):
+                self._valign[new_name] = self._valign[old_name]
+            for old_name in old_names:
+                if old_name not in self._valign:
+                    self._valign.pop(old_name)
+        else:
+            self.valign = "t"
+
+    @property
+    def align(self):
+        """Controls alignment of fields
+        Arguments:
+
+        align - alignment, one of "l", "c", or "r" """
+        return self._align
+
+    @align.setter
+    def align(self, val) -> None:
+        if val is None or (isinstance(val, dict) and len(val) == 0):
+            if not self._field_names:
+                self._align = {BASE_ALIGN_VALUE: "c"}
+            else:
+                for field in self._field_names:
+                    self._align[field] = "c"
+        else:
+            self._validate_align(val)
+            if not self._field_names:
+                self._align = {BASE_ALIGN_VALUE: val}
+            else:
+                for field in self._field_names:
+                    self._align[field] = val
+
+    @property
+    def valign(self):
+        """Controls vertical alignment of fields
+        Arguments:
+
+        valign - vertical alignment, one of "t", "m", or "b" """
+        return self._valign
+
+    @valign.setter
+    def valign(self, val) -> None:
+        if not self._field_names:
+            self._valign = {}
+        elif val is None or (isinstance(val, dict) and len(val) == 0):
+            for field in self._field_names:
+                self._valign[field] = "t"
+        else:
+            self._validate_valign(val)
+            for field in self._field_names:
+                self._valign[field] = val
+
+    @property
+    def max_width(self):
+        """Controls maximum width of fields
+        Arguments:
+
+        max_width - maximum width integer"""
+        return self._max_width
+
+    @max_width.setter
+    def max_width(self, val) -> None:
+        if val is None or (isinstance(val, dict) and len(val) == 0):
+            self._max_width = {}
+        else:
+            self._validate_option("max_width", val)
+            for field in self._field_names:
+                self._max_width[field] = val
+
+    @property
+    def min_width(self):
+        """Controls minimum width of fields
+        Arguments:
+
+        min_width - minimum width integer"""
+        return self._min_width
+
+    @min_width.setter
+    def min_width(self, val) -> None:
+        if val is None or (isinstance(val, dict) and len(val) == 0):
+            self._min_width = {}
+        else:
+            self._validate_option("min_width", val)
+            for field in self._field_names:
+                self._min_width[field] = val
+
+    @property
+    def min_table_width(self) -> int | None:
+        return self._min_table_width
+
+    @min_table_width.setter
+    def min_table_width(self, val: int) -> None:
+        self._validate_option("min_table_width", val)
+        self._min_table_width = val
+
+    @property
+    def max_table_width(self) -> int | None:
+        return self._max_table_width
+
+    @max_table_width.setter
+    def max_table_width(self, val: int) -> None:
+        self._validate_option("max_table_width", val)
+        self._max_table_width = val
+
+    @property
+    def fields(self) -> Sequence[str | None] | None:
+        """List or tuple of field names to include in displays"""
+        return self._fields
+
+    @fields.setter
+    def fields(self, val: Sequence[str | None]) -> None:
+        self._validate_option("fields", val)
+        self._fields = val
+
+    @property
+    def title(self) -> str | None:
+        """Optional table title
+
+        Arguments:
+
+        title - table title"""
+        return self._title
+
+    @title.setter
+    def title(self, val: str) -> None:
+        self._title = str(val)
+
+    @property
+    def start(self) -> int:
+        """Start index of the range of rows to print
+
+        Arguments:
+
+        start - index of first data row to include in output"""
+        return self._start
+
+    @start.setter
+    def start(self, val: int) -> None:
+        self._validate_option("start", val)
+        self._start = val
+
+    @property
+    def end(self) -> int | None:
+        """End index of the range of rows to print
+
+        Arguments:
+
+        end - index of last data row to include in output PLUS ONE (list slice style)"""
+        return self._end
+
+    @end.setter
+    def end(self, val: int) -> None:
+        self._validate_option("end", val)
+        self._end = val
+
+    @property
+    def sortby(self) -> str | None:
+        """Name of field by which to sort rows
+
+        Arguments:
+
+        sortby - field name to sort by"""
+        return self._sortby
+
+    @sortby.setter
+    def sortby(self, val: str | None) -> None:
+        self._validate_option("sortby", val)
+        self._sortby = val
+
+    @property
+    def reversesort(self) -> bool:
+        """Controls direction of sorting (ascending vs descending)
+
+        Arguments:
+
+        reveresort - set to True to sort by descending order, or False to sort by
+            ascending order"""
+        return self._reversesort
+
+    @reversesort.setter
+    def reversesort(self, val: bool) -> None:
+        self._validate_option("reversesort", val)
+        self._reversesort = val
+
+    @property
+    def sort_key(self) -> Callable[[RowType], SupportsRichComparison]:
+        """Sorting key function, applied to data points before sorting
+
+        Arguments:
+
+        sort_key - a function which takes one argument and returns something to be
+        sorted"""
+        return self._sort_key
+
+    @sort_key.setter
+    def sort_key(self, val: Callable[[RowType], SupportsRichComparison]) -> None:
+        self._validate_option("sort_key", val)
+        self._sort_key = val
+
+    @property
+    def header(self) -> bool:
+        """Controls printing of table header with field names
+
+        Arguments:
+
+        header - print a header showing field names (True or False)"""
+        return self._header
+
+    @header.setter
+    def header(self, val: bool) -> None:
+        self._validate_option("header", val)
+        self._header = val
+
+    @property
+    def header_style(self) -> HeaderStyleType:
+        """Controls stylisation applied to field names in header
+
+        Arguments:
+
+        header_style - stylisation to apply to field names in header
+            ("cap", "title", "upper", "lower" or None)"""
+        return self._header_style
+
+    @header_style.setter
+    def header_style(self, val: HeaderStyleType) -> None:
+        self._validate_header_style(val)
+        self._header_style = val
+
+    @property
+    def border(self) -> bool:
+        """Controls printing of border around table
+
+        Arguments:
+
+        border - print a border around the table (True or False)"""
+        return self._border
+
+    @border.setter
+    def border(self, val: bool) -> None:
+        self._validate_option("border", val)
+        self._border = val
+
+    @property
+    def preserve_internal_border(self) -> bool:
+        """Controls printing of border inside table
+
+        Arguments:
+
+        preserve_internal_border - print a border inside the table even if
+            border is disabled (True or False)"""
+        return self._preserve_internal_border
+
+    @preserve_internal_border.setter
+    def preserve_internal_border(self, val: bool) -> None:
+        self._validate_option("preserve_internal_border", val)
+        self._preserve_internal_border = val
+
+    @property
+    def hrules(self) -> HRuleStyle:
+        """Controls printing of horizontal rules after rows
+
+        Arguments:
+
+        hrules - horizontal rules style.  Allowed values: HRuleStyle"""
+        return self._hrules
+
+    @hrules.setter
+    def hrules(self, val: HRuleStyle) -> None:
+        self._validate_option("hrules", val)
+        self._hrules = val
+
+    @property
+    def vrules(self) -> VRuleStyle:
+        """Controls printing of vertical rules between columns
+
+        Arguments:
+
+        vrules - vertical rules style.  Allowed values: VRuleStyle"""
+        return self._vrules
+
+    @vrules.setter
+    def vrules(self, val: VRuleStyle) -> None:
+        self._validate_option("vrules", val)
+        self._vrules = val
+
+    @property
+    def int_format(self):
+        """Controls formatting of integer data
+        Arguments:
+
+        int_format - integer format string"""
+        return self._int_format
+
+    @int_format.setter
+    def int_format(self, val) -> None:
+        if val is None or (isinstance(val, dict) and len(val) == 0):
+            self._int_format = {}
+        else:
+            self._validate_option("int_format", val)
+            for field in self._field_names:
+                self._int_format[field] = val
+
+    @property
+    def float_format(self):
+        """Controls formatting of floating point data
+        Arguments:
+
+        float_format - floating point format string"""
+        return self._float_format
+
+    @float_format.setter
+    def float_format(self, val) -> None:
+        if val is None or (isinstance(val, dict) and len(val) == 0):
+            self._float_format = {}
+        else:
+            self._validate_option("float_format", val)
+            for field in self._field_names:
+                self._float_format[field] = val
+
+    @property
+    def custom_format(self):
+        """Controls formatting of any column using callable
+        Arguments:
+
+        custom_format - Dictionary of field_name and callable"""
+        return self._custom_format
+
+    @custom_format.setter
+    def custom_format(self, val):
+        if val is None:
+            self._custom_format = {}
+        elif isinstance(val, dict):
+            for k, v in val.items():
+                self._validate_function(f"custom_value.{k}", v)
+            self._custom_format = val
+        elif hasattr(val, "__call__"):
+            self._validate_function("custom_value", val)
+            for field in self._field_names:
+                self._custom_format[field] = val
+        else:
+            msg = "The custom_format property need to be a dictionary or callable"
+            raise TypeError(msg)
+
+    @property
+    def padding_width(self) -> int:
+        """The number of empty spaces between a column's edge and its content
+
+        Arguments:
+
+        padding_width - number of spaces, must be a positive integer"""
+        return self._padding_width
+
+    @padding_width.setter
+    def padding_width(self, val: int) -> None:
+        self._validate_option("padding_width", val)
+        self._padding_width = val
+
+    @property
+    def left_padding_width(self) -> int | None:
+        """The number of empty spaces between a column's left edge and its content
+
+        Arguments:
+
+        left_padding - number of spaces, must be a positive integer"""
+        return self._left_padding_width
+
+    @left_padding_width.setter
+    def left_padding_width(self, val: int) -> None:
+        self._validate_option("left_padding_width", val)
+        self._left_padding_width = val
+
+    @property
+    def right_padding_width(self) -> int | None:
+        """The number of empty spaces between a column's right edge and its content
+
+        Arguments:
+
+        right_padding - number of spaces, must be a positive integer"""
+        return self._right_padding_width
+
+    @right_padding_width.setter
+    def right_padding_width(self, val: int) -> None:
+        self._validate_option("right_padding_width", val)
+        self._right_padding_width = val
+
+    @property
+    def vertical_char(self) -> str:
+        """The character used when printing table borders to draw vertical lines
+
+        Arguments:
+
+        vertical_char - single character string used to draw vertical lines"""
+        return self._vertical_char
+
+    @vertical_char.setter
+    def vertical_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("vertical_char", val)
+        self._vertical_char = val
+
+    @property
+    def horizontal_char(self) -> str:
+        """The character used when printing table borders to draw horizontal lines
+
+        Arguments:
+
+        horizontal_char - single character string used to draw horizontal lines"""
+        return self._horizontal_char
+
+    @horizontal_char.setter
+    def horizontal_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("horizontal_char", val)
+        self._horizontal_char = val
+
+    @property
+    def horizontal_align_char(self) -> str:
+        """The character used to indicate column alignment in horizontal lines
+
+        Arguments:
+
+        horizontal_align_char - single character string used to indicate alignment"""
+        return self._bottom_left_junction_char or self.junction_char
+
+    @horizontal_align_char.setter
+    def horizontal_align_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("horizontal_align_char", val)
+        self._horizontal_align_char = val
+
+    @property
+    def junction_char(self) -> str:
+        """The character used when printing table borders to draw line junctions
+
+        Arguments:
+
+        junction_char - single character string used to draw line junctions"""
+        return self._junction_char
+
+    @junction_char.setter
+    def junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("junction_char", val)
+        self._junction_char = val
+
+    @property
+    def top_junction_char(self) -> str:
+        """The character used when printing table borders to draw top line junctions
+
+        Arguments:
+
+        top_junction_char - single character string used to draw top line junctions"""
+        return self._top_junction_char or self.junction_char
+
+    @top_junction_char.setter
+    def top_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("top_junction_char", val)
+        self._top_junction_char = val
+
+    @property
+    def bottom_junction_char(self) -> str:
+        """The character used when printing table borders to draw bottom line junctions
+
+        Arguments:
+
+        bottom_junction_char -
+            single character string used to draw bottom line junctions"""
+        return self._bottom_junction_char or self.junction_char
+
+    @bottom_junction_char.setter
+    def bottom_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("bottom_junction_char", val)
+        self._bottom_junction_char = val
+
+    @property
+    def right_junction_char(self) -> str:
+        """The character used when printing table borders to draw right line junctions
+
+        Arguments:
+
+        right_junction_char -
+            single character string used to draw right line junctions"""
+        return self._right_junction_char or self.junction_char
+
+    @right_junction_char.setter
+    def right_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("right_junction_char", val)
+        self._right_junction_char = val
+
+    @property
+    def left_junction_char(self) -> str:
+        """The character used when printing table borders to draw left line junctions
+
+        Arguments:
+
+        left_junction_char - single character string used to draw left line junctions"""
+        return self._left_junction_char or self.junction_char
+
+    @left_junction_char.setter
+    def left_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("left_junction_char", val)
+        self._left_junction_char = val
+
+    @property
+    def top_right_junction_char(self) -> str:
+        """
+        The character used when printing table borders to draw top-right line junctions
+
+        Arguments:
+
+        top_right_junction_char -
+            single character string used to draw top-right line junctions"""
+        return self._top_right_junction_char or self.junction_char
+
+    @top_right_junction_char.setter
+    def top_right_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("top_right_junction_char", val)
+        self._top_right_junction_char = val
+
+    @property
+    def top_left_junction_char(self) -> str:
+        """
+        The character used when printing table borders to draw top-left line junctions
+
+        Arguments:
+
+        top_left_junction_char -
+            single character string used to draw top-left line junctions"""
+        return self._top_left_junction_char or self.junction_char
+
+    @top_left_junction_char.setter
+    def top_left_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("top_left_junction_char", val)
+        self._top_left_junction_char = val
+
+    @property
+    def bottom_right_junction_char(self) -> str:
+        """The character used when printing table borders
+           to draw bottom-right line junctions
+
+        Arguments:
+
+        bottom_right_junction_char -
+            single character string used to draw bottom-right line junctions"""
+        return self._bottom_right_junction_char or self.junction_char
+
+    @bottom_right_junction_char.setter
+    def bottom_right_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("bottom_right_junction_char", val)
+        self._bottom_right_junction_char = val
+
+    @property
+    def bottom_left_junction_char(self) -> str:
+        """The character used when printing table borders
+           to draw bottom-left line junctions
+
+        Arguments:
+
+        bottom_left_junction_char -
+            single character string used to draw bottom-left line junctions"""
+        return self._bottom_left_junction_char or self.junction_char
+
+    @bottom_left_junction_char.setter
+    def bottom_left_junction_char(self, val: str) -> None:
+        val = str(val)
+        self._validate_option("bottom_left_junction_char", val)
+        self._bottom_left_junction_char = val
+
+    @property
+    def format(self) -> bool:
+        """Controls whether or not HTML tables are formatted to match styling options
+
+        Arguments:
+
+        format - True or False"""
+        return self._format
+
+    @format.setter
+    def format(self, val: bool) -> None:
+        self._validate_option("format", val)
+        self._format = val
+
+    @property
+    def print_empty(self) -> bool:
+        """Controls whether or not empty tables produce a header and frame or just an
+        empty string
+
+        Arguments:
+
+        print_empty - True or False"""
+        return self._print_empty
+
+    @print_empty.setter
+    def print_empty(self, val: bool) -> None:
+        self._validate_option("print_empty", val)
+        self._print_empty = val
+
+    @property
+    def attributes(self) -> dict[str, str]:
+        """A dictionary of HTML attribute name/value pairs to be included in the
+        <table> tag when printing HTML
+
+        Arguments:
+
+        attributes - dictionary of attributes"""
+        return self._attributes
+
+    @attributes.setter
+    def attributes(self, val: dict[str, str]) -> None:
+        self._validate_option("attributes", val)
+        self._attributes = val
+
+    @property
+    def oldsortslice(self) -> bool:
+        """oldsortslice - Slice rows before sorting in the "old style" """
+        return self._oldsortslice
+
+    @oldsortslice.setter
+    def oldsortslice(self, val: bool) -> None:
+        self._validate_option("oldsortslice", val)
+        self._oldsortslice = val
+
+    @property
+    def escape_header(self) -> bool:
+        """Escapes the text within a header (True or False)"""
+        return self._escape_header
+
+    @escape_header.setter
+    def escape_header(self, val: bool) -> None:
+        self._validate_option("escape_header", val)
+        self._escape_header = val
+
+    @property
+    def escape_data(self) -> bool:
+        """Escapes the text within a data field (True or False)"""
+        return self._escape_data
+
+    @escape_data.setter
+    def escape_data(self, val: bool) -> None:
+        self._validate_option("escape_data", val)
+        self._escape_data = val
+
+    ##############################
+    # OPTION MIXER               #
+    ##############################
+
+    def _get_options(self, kwargs: Mapping[str, Any]) -> OptionsType:
+        options: dict[str, Any] = {}
+        for option in self._options:
+            if option in kwargs:
+                self._validate_option(option, kwargs[option])
+                options[option] = kwargs[option]
+            else:
+                options[option] = getattr(self, option)
+        return cast(OptionsType, options)
+
+    ##############################
+    # PRESET STYLE LOGIC         #
+    ##############################
+
+    def set_style(self, style: TableStyle) -> None:
+        self._set_default_style()
+        self._style = style
+        if style == TableStyle.MSWORD_FRIENDLY:
+            self._set_msword_style()
+        elif style == TableStyle.PLAIN_COLUMNS:
+            self._set_columns_style()
+        elif style == TableStyle.MARKDOWN:
+            self._set_markdown_style()
+        elif style == TableStyle.ORGMODE:
+            self._set_orgmode_style()
+        elif style == TableStyle.DOUBLE_BORDER:
+            self._set_double_border_style()
+        elif style == TableStyle.SINGLE_BORDER:
+            self._set_single_border_style()
+        elif style == TableStyle.RANDOM:
+            self._set_random_style()
+        elif style != TableStyle.DEFAULT:
+            msg = "Invalid pre-set style"
+            raise ValueError(msg)
+
+    def _set_orgmode_style(self) -> None:
+        self.orgmode = True
+
+    def _set_markdown_style(self) -> None:
+        self.header = True
+        self.border = True
+        self._hrules = HRuleStyle.HEADER
+        self.padding_width = 1
+        self.left_padding_width = 1
+        self.right_padding_width = 1
+        self.vertical_char = "|"
+        self.junction_char = "|"
+        self._horizontal_align_char = ":"
+
+    def _set_default_style(self) -> None:
+        self.header = True
+        self.border = True
+        self._hrules = HRuleStyle.FRAME
+        self._vrules = VRuleStyle.ALL
+        self.padding_width = 1
+        self.left_padding_width = 1
+        self.right_padding_width = 1
+        self.vertical_char = "|"
+        self.horizontal_char = "-"
+        self._horizontal_align_char = None
+        self.junction_char = "+"
+        self._top_junction_char = None
+        self._bottom_junction_char = None
+        self._right_junction_char = None
+        self._left_junction_char = None
+        self._top_right_junction_char = None
+        self._top_left_junction_char = None
+        self._bottom_right_junction_char = None
+        self._bottom_left_junction_char = None
+
+    def _set_msword_style(self) -> None:
+        self.header = True
+        self.border = True
+        self._hrules = HRuleStyle.NONE
+        self.padding_width = 1
+        self.left_padding_width = 1
+        self.right_padding_width = 1
+        self.vertical_char = "|"
+
+    def _set_columns_style(self) -> None:
+        self.header = True
+        self.border = False
+        self.padding_width = 1
+        self.left_padding_width = 0
+        self.right_padding_width = 8
+
+    def _set_double_border_style(self) -> None:
+        self.horizontal_char = "═"
+        self.vertical_char = "║"
+        self.junction_char = "╬"
+        self.top_junction_char = "╦"
+        self.bottom_junction_char = "╩"
+        self.right_junction_char = "╣"
+        self.left_junction_char = "╠"
+        self.top_right_junction_char = "╗"
+        self.top_left_junction_char = "╔"
+        self.bottom_right_junction_char = "╝"
+        self.bottom_left_junction_char = "╚"
+
+    def _set_single_border_style(self) -> None:
+        self.horizontal_char = "─"
+        self.vertical_char = "│"
+        self.junction_char = "┼"
+        self.top_junction_char = "┬"
+        self.bottom_junction_char = "┴"
+        self.right_junction_char = "┤"
+        self.left_junction_char = "├"
+        self.top_right_junction_char = "┐"
+        self.top_left_junction_char = "┌"
+        self.bottom_right_junction_char = "┘"
+        self.bottom_left_junction_char = "└"
+
+    def _set_random_style(self) -> None:
+        # Just for fun!
+        import random
+
+        self.header = random.choice((True, False))
+        self.border = random.choice((True, False))
+        self._hrules = random.choice(list(HRuleStyle))
+        self._vrules = random.choice(list(VRuleStyle))
+        self.left_padding_width = random.randint(0, 5)
+        self.right_padding_width = random.randint(0, 5)
+        self.vertical_char = random.choice(r"~!@#$%^&*()_+|-=\{}[];':\",./;<>?")
+        self.horizontal_char = random.choice(r"~!@#$%^&*()_+|-=\{}[];':\",./;<>?")
+        self.junction_char = random.choice(r"~!@#$%^&*()_+|-=\{}[];':\",./;<>?")
+        self.preserve_internal_border = random.choice((True, False))
+
+    ##############################
+    # DATA INPUT METHODS         #
+    ##############################
+
+    def add_rows(self, rows: Iterable[RowType]) -> None:
+        """Add rows to the table
+
+        Arguments:
+
+        rows - rows of data, should be an iterable of lists, each list with as many
+        elements as the table has fields"""
+        for row in rows:
+            self.add_row(row)
+
+    def add_row(self, row: RowType, *, divider: bool = False) -> None:
+        """Add a row to the table
+
+        Arguments:
+
+        row - row of data, should be a list with as many elements as the table
+        has fields"""
+
+        if self._field_names and len(row) != len(self._field_names):
+            msg = (
+                "Row has incorrect number of values, "
+                f"(actual) {len(row)}!={len(self._field_names)} (expected)"
+            )
+            raise ValueError(msg)
+        if not self._field_names:
+            self.field_names = [f"Field {n + 1}" for n in range(0, len(row))]
+        self._rows.append(list(row))
+        self._dividers.append(divider)
+
+    def del_row(self, row_index: int) -> None:
+        """Delete a row from the table
+
+        Arguments:
+
+        row_index - The index of the row you want to delete.  Indexing starts at 0."""
+
+        if row_index > len(self._rows) - 1:
+            msg = (
+                f"Can't delete row at index {row_index}, "
+                f"table only has {len(self._rows)} rows"
+            )
+            raise IndexError(msg)
+        del self._rows[row_index]
+        del self._dividers[row_index]
+
+    def add_divider(self) -> None:
+        """Add a divider to the table"""
+        if len(self._dividers) >= 1:
+            self._dividers[-1] = True
+
+    def add_column(
+        self,
+        fieldname: str,
+        column: Sequence[Any],
+        align: AlignType = "c",
+        valign: VAlignType = "t",
+    ) -> None:
+        """Add a column to the table.
+
+        Arguments:
+
+        fieldname - name of the field to contain the new column of data
+        column - column of data, should be a list with as many elements as the
+        table has rows
+        align - desired alignment for this column - "l" for left, "c" for centre and
+            "r" for right
+        valign - desired vertical alignment for new columns - "t" for top,
+            "m" for middle and "b" for bottom"""
+
+        if len(self._rows) in (0, len(column)):
+            self._validate_align(align)
+            self._validate_valign(valign)
+            self._field_names.append(fieldname)
+            self._align[fieldname] = align
+            self._valign[fieldname] = valign
+            for i in range(0, len(column)):
+                if len(self._rows) < i + 1:
+                    self._rows.append([])
+                    self._dividers.append(False)
+                self._rows[i].append(column[i])
+        else:
+            msg = (
+                f"Column length {len(column)} does not match number of rows "
+                f"{len(self._rows)}"
+            )
+            raise ValueError(msg)
+
+    def add_autoindex(self, fieldname: str = "Index") -> None:
+        """Add an auto-incrementing index column to the table.
+        Arguments:
+        fieldname - name of the field to contain the new column of data"""
+        self._field_names.insert(0, fieldname)
+        self._align[fieldname] = self._kwargs["align"] or "c"
+        self._valign[fieldname] = self._kwargs["valign"] or "t"
+        for i, row in enumerate(self._rows):
+            row.insert(0, i + 1)
+
+    def del_column(self, fieldname: str) -> None:
+        """Delete a column from the table
+
+        Arguments:
+
+        fieldname - The field name of the column you want to delete."""
+
+        if fieldname not in self._field_names:
+            msg = (
+                "Can't delete column {!r} which is not a field name of this table."
+                " Field names are: {}".format(
+                    fieldname, ", ".join(map(repr, self._field_names))
+                )
+            )
+            raise ValueError(msg)
+
+        col_index = self._field_names.index(fieldname)
+        del self._field_names[col_index]
+        for row in self._rows:
+            del row[col_index]
+
+    def clear_rows(self) -> None:
+        """Delete all rows from the table but keep the current field names"""
+
+        self._rows = []
+        self._dividers = []
+
+    def clear(self) -> None:
+        """Delete all rows and field names from the table, maintaining nothing but
+        styling options"""
+
+        self._rows = []
+        self._dividers = []
+        self._field_names = []
+        self._widths = []
+
+    ##############################
+    # MISC PUBLIC METHODS        #
+    ##############################
+
+    def copy(self) -> Self:
+        import copy
+
+        return copy.deepcopy(self)
+
+    def get_formatted_string(self, out_format: str = "text", **kwargs) -> str:
+        """Return string representation of specified format of table in current state.
+
+        Arguments:
+        out_format - resulting table format
+        kwargs - passed through to function that performs formatting
+        """
+        if out_format == "text":
+            return self.get_string(**kwargs)
+        if out_format == "html":
+            return self.get_html_string(**kwargs)
+        if out_format == "json":
+            return self.get_json_string(**kwargs)
+        if out_format == "csv":
+            return self.get_csv_string(**kwargs)
+        if out_format == "latex":
+            return self.get_latex_string(**kwargs)
+
+        msg = (
+            f"Invalid format {out_format}. "
+            "Must be one of: text, html, json, csv, or latex"
+        )
+        raise ValueError(msg)
+
+    ##############################
+    # MISC PRIVATE METHODS       #
+    ##############################
+
+    def _format_value(self, field: str, value: Any) -> str:
+        if isinstance(value, int) and field in self._int_format:
+            return (f"%{self._int_format[field]}d") % value
+        elif isinstance(value, float) and field in self._float_format:
+            return (f"%{self._float_format[field]}f") % value
+
+        formatter = self._custom_format.get(field, (lambda f, v: str(v)))
+        return formatter(field, value)
+
+    def _compute_table_width(self, options) -> int:
+        if options["vrules"] == VRuleStyle.FRAME:
+            table_width = 2
+        if options["vrules"] == VRuleStyle.ALL:
+            table_width = 1
+        else:
+            table_width = 0
+        per_col_padding = sum(self._get_padding_widths(options))
+        for index, fieldname in enumerate(self.field_names):
+            if not options["fields"] or (
+                options["fields"] and fieldname in options["fields"]
+            ):
+                table_width += self._widths[index] + per_col_padding + 1
+        return table_width
+
+    def _compute_widths(self, rows: list[list[str]], options: OptionsType) -> None:
+        if options["header"]:
+            widths = [_get_size(field)[0] for field in self._field_names]
+        else:
+            widths = len(self.field_names) * [0]
+
+        for row in rows:
+            for index, value in enumerate(row):
+                fieldname = self.field_names[index]
+                if (
+                    value == "None"
+                    and (none_val := self.none_format.get(fieldname)) is not None
+                ):
+                    value = none_val
+                if fieldname in self.max_width:
+                    widths[index] = max(
+                        widths[index],
+                        min(_get_size(value)[0], self.max_width[fieldname]),
+                    )
+                else:
+                    widths[index] = max(widths[index], _get_size(value)[0])
+                if fieldname in self.min_width:
+                    widths[index] = max(widths[index], self.min_width[fieldname])
+
+                if self._style == TableStyle.MARKDOWN:
+                    # Markdown needs at least one hyphen in the divider
+                    if self._align[fieldname] in ("l", "r"):
+                        min_width = 1
+                    else:  # "c"
+                        min_width = 3
+                    widths[index] = max(min_width, widths[index])
+
+        self._widths = widths
+
+        per_col_padding = sum(self._get_padding_widths(options))
+        # Are we exceeding max_table_width?
+        if self._max_table_width:
+            table_width = self._compute_table_width(options)
+            if table_width > self._max_table_width:
+                # Shrink widths in proportion
+                markup_chars = per_col_padding * len(widths) + len(widths) - 1
+                scale = (self._max_table_width - markup_chars) / (
+                    table_width - markup_chars
+                )
+                self._widths = [max(1, int(w * scale)) for w in widths]
+
+        # Are we under min_table_width or title width?
+        if self._min_table_width or options["title"]:
+            if options["title"]:
+                title_width = len(options["title"]) + per_col_padding
+                if options["vrules"] in (VRuleStyle.FRAME, VRuleStyle.ALL):
+                    title_width += 2
+            else:
+                title_width = 0
+            min_table_width = self.min_table_width or 0
+            min_width = max(title_width, min_table_width)
+            if options["border"]:
+                borders = len(widths) + 1
+            elif options["preserve_internal_border"]:
+                borders = len(widths)
+            else:
+                borders = 0
+
+            # Subtract padding for each column and borders
+            min_width -= sum([per_col_padding for _ in widths]) + borders
+            # What is being scaled is content so we sum column widths
+            content_width = sum(widths) or 1
+
+            if content_width < min_width:
+                # Grow widths in proportion
+                scale = 1.0 * min_width / content_width
+                widths = [int(w * scale) for w in widths]
+                if sum(widths) < min_width:
+                    widths[-1] += min_width - sum(widths)
+                self._widths = widths
+
+    def _get_padding_widths(self, options: OptionsType) -> tuple[int, int]:
+        if options["left_padding_width"] is not None:
+            lpad = options["left_padding_width"]
+        else:
+            lpad = options["padding_width"]
+        if options["right_padding_width"] is not None:
+            rpad = options["right_padding_width"]
+        else:
+            rpad = options["padding_width"]
+        return lpad, rpad
+
+    def _get_rows(self, options: OptionsType) -> list[RowType]:
+        """Return only those data rows that should be printed, based on slicing and
+        sorting.
+
+        Arguments:
+
+        options - dictionary of option settings."""
+        import copy
+
+        if options["oldsortslice"]:
+            rows = copy.deepcopy(self._rows[options["start"]: options["end"]])
+        else:
+            rows = copy.deepcopy(self._rows)
+
+        # Sort
+        if options["sortby"]:
+            sortindex = self._field_names.index(options["sortby"])
+            # Decorate
+            rows = [[row[sortindex]] + row for row in rows]
+            # Sort
+            rows.sort(reverse=options["reversesort"], key=options["sort_key"])
+            # Undecorate
+            rows = [row[1:] for row in rows]
+
+        # Slice if necessary
+        if not options["oldsortslice"]:
+            rows = rows[options["start"]: options["end"]]
+
+        return rows
+
+    def _get_dividers(self, options: OptionsType) -> list[bool]:
+        """Return only those dividers that should be printed, based on slicing.
+
+        Arguments:
+
+        options - dictionary of option settings."""
+        import copy
+
+        if options["oldsortslice"]:
+            dividers = copy.deepcopy(self._dividers[options["start"]: options["end"]])
+        else:
+            dividers = copy.deepcopy(self._dividers)
+
+        if options["sortby"]:
+            dividers = [False for divider in dividers]
+
+        return dividers
+
+    def _format_row(self, row: RowType) -> list[str]:
+        return [
+            self._format_value(field, value)
+            for (field, value) in zip(self._field_names, row)
+        ]
+
+    def _format_rows(self, rows: list[RowType]) -> list[list[str]]:
+        return [self._format_row(row) for row in rows]
+
+    ##############################
+    # PLAIN TEXT STRING METHODS  #
+    ##############################
+
+    def get_string(self, **kwargs) -> str:
+        """Return string representation of table in current state.
+
+        Arguments:
+
+        title - optional table title
+        start - index of first data row to include in output
+        end - index of last data row to include in output PLUS ONE (list slice style)
+        fields - names of fields (columns) to include
+        header - print a header showing field names (True or False)
+        border - print a border around the table (True or False)
+        preserve_internal_border - print a border inside the table even if
+            border is disabled (True or False)
+        hrules - controls printing of horizontal rules after rows.
+            Allowed values: HRuleStyle
+        vrules - controls printing of vertical rules between columns.
+            Allowed values: VRuleStyle
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
+        custom_format - controls formatting of any column using callable
+        padding_width - number of spaces on either side of column data (only used if
+            left and right paddings are None)
+        left_padding_width - number of spaces on left hand side of column data
+        right_padding_width - number of spaces on right hand side of column data
+        vertical_char - single character string used to draw vertical lines
+        horizontal_char - single character string used to draw horizontal lines
+        horizontal_align_char - single character string used to indicate alignment
+        junction_char - single character string used to draw line junctions
+        junction_char - single character string used to draw line junctions
+        top_junction_char - single character string used to draw top line junctions
+        bottom_junction_char -
+            single character string used to draw bottom line junctions
+        right_junction_char - single character string used to draw right line junctions
+        left_junction_char - single character string used to draw left line junctions
+        top_right_junction_char -
+            single character string used to draw top-right line junctions
+        top_left_junction_char -
+            single character string used to draw top-left line junctions
+        bottom_right_junction_char -
+            single character string used to draw bottom-right line junctions
+        bottom_left_junction_char -
+            single character string used to draw bottom-left line junctions
+        sortby - name of field to sort rows by
+        sort_key - sorting key function, applied to data points before sorting
+        reversesort - True or False to sort in descending or ascending order
+        print empty - if True, stringify just the header for an empty table,
+            if False return an empty string"""
+
+        options = self._get_options(kwargs)
+
+        lines: list[str] = []
+
+        # Don't think too hard about an empty table
+        # Is this the desired behaviour?  Maybe we should still print the header?
+        if self.rowcount == 0 and (not options["print_empty"] or not options["border"]):
+            return ""
+
+        # Get the rows we need to print, taking into account slicing, sorting, etc.
+        rows = self._get_rows(options)
+        dividers = self._get_dividers(options)
+
+        # Turn all data in all rows into Unicode, formatted as desired
+        formatted_rows = self._format_rows(rows)
+
+        # Compute column widths
+        self._compute_widths(formatted_rows, options)
+        self._hrule = self._stringify_hrule(options)
+
+        # Add title
+        title = options["title"] or self._title
+        if title:
+            lines.append(self._stringify_title(title, options))
+
+        # Add header or top of border
+        if options["header"]:
+            lines.append(self._stringify_header(options))
+        elif options["border"] and options["hrules"] in (
+            HRuleStyle.ALL,
+            HRuleStyle.FRAME,
+        ):
+            lines.append(self._stringify_hrule(options, where="top_"))
+            if title and options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME):
+                left_j_len = len(self.left_junction_char)
+                right_j_len = len(self.right_junction_char)
+                lines[-1] = (
+                    self.left_junction_char
+                    + lines[-1][left_j_len:-right_j_len]
+                    + self.right_junction_char
+                )
+
+        # Add rows
+        for row, divider in zip(formatted_rows[:-1], dividers[:-1]):
+            lines.append(self._stringify_row(row, options, self._hrule))
+            if divider:
+                lines.append(self._stringify_hrule(options))
+        if formatted_rows:
+            lines.append(
+                self._stringify_row(
+                    formatted_rows[-1],
+                    options,
+                    self._stringify_hrule(options, where="bottom_"),
+                )
+            )
+
+        # Add bottom of border
+        if options["border"] and options["hrules"] == HRuleStyle.FRAME:
+            lines.append(self._stringify_hrule(options, where="bottom_"))
+
+        if "orgmode" in self.__dict__ and self.orgmode:
+            left_j_len = len(self.left_junction_char)
+            right_j_len = len(self.right_junction_char)
+            lines = [
+                "|" + new_line[left_j_len:-right_j_len] + "|"
+                for old_line in lines
+                for new_line in old_line.split("\n")
+            ]
+
+        return "\n".join(lines)
+
+    def _stringify_hrule(
+        self, options: OptionsType, where: Literal["top_", "bottom_", ""] = ""
+    ) -> str:
+        if not options["border"] and not options["preserve_internal_border"]:
+            return ""
+        lpad, rpad = self._get_padding_widths(options)
+        if options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME):
+            bits = [options[where + "left_junction_char"]]  # type: ignore[literal-required]
+        else:
+            bits = [options["horizontal_char"]]
+        # For tables with no data or fieldnames
+        if not self._field_names:
+            bits.append(options[where + "right_junction_char"])  # type: ignore[literal-required]
+            return "".join(bits)
+        for field, width in zip(self._field_names, self._widths):
+            if options["fields"] and field not in options["fields"]:
+                continue
+
+            line = (width + lpad + rpad) * options["horizontal_char"]
+
+            # If necessary, add column alignment characters (e.g. ":" for Markdown)
+            if self._horizontal_align_char:
+                if self._align[field] in ("l", "c"):
+                    line = " " + self._horizontal_align_char + line[2:]
+                if self._align[field] in ("c", "r"):
+                    line = line[:-2] + self._horizontal_align_char + " "
+
+            bits.append(line)
+            if options["vrules"] == VRuleStyle.ALL:
+                bits.append(options[where + "junction_char"])  # type: ignore[literal-required]
+            else:
+                bits.append(options["horizontal_char"])
+        if options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME):
+            bits.pop()
+            bits.append(options[where + "right_junction_char"])  # type: ignore[literal-required]
+
+        if options["preserve_internal_border"] and not options["border"]:
+            bits = bits[1:-1]
+
+        return "".join(bits)
+
+    def _stringify_title(self, title: str, options: OptionsType) -> str:
+        lines: list[str] = []
+        lpad, rpad = self._get_padding_widths(options)
+        if options["border"]:
+            if options["vrules"] == VRuleStyle.ALL:
+                options["vrules"] = VRuleStyle.FRAME
+                lines.append(self._stringify_hrule(options, "top_"))
+                options["vrules"] = VRuleStyle.ALL
+            elif options["vrules"] == VRuleStyle.FRAME:
+                lines.append(self._stringify_hrule(options, "top_"))
+        bits: list[str] = []
+        endpoint = (
+            options["vertical_char"]
+            if options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME)
+               and options["border"]
+            else " "
+        )
+        bits.append(endpoint)
+        title = " " * lpad + title + " " * rpad
+        lpad, rpad = self._get_padding_widths(options)
+        sum_widths = sum([n + lpad + rpad + 1 for n in self._widths])
+
+        bits.append(self._justify(title, sum_widths - 1, "c"))
+        bits.append(endpoint)
+        lines.append("".join(bits))
+        return "\n".join(lines)
+
+    def _stringify_header(self, options: OptionsType) -> str:
+        bits: list[str] = []
+        lpad, rpad = self._get_padding_widths(options)
+        if options["border"]:
+            if options["hrules"] in (HRuleStyle.ALL, HRuleStyle.FRAME):
+                bits.append(self._stringify_hrule(options, "top_"))
+                if options["title"] and options["vrules"] in (
+                    VRuleStyle.ALL,
+                    VRuleStyle.FRAME,
+                ):
+                    left_j_len = len(self.left_junction_char)
+                    right_j_len = len(self.right_junction_char)
+                    bits[-1] = (
+                        self.left_junction_char
+                        + bits[-1][left_j_len:-right_j_len]
+                        + self.right_junction_char
+                    )
+                bits.append("\n")
+            if options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME):
+                bits.append(options["vertical_char"])
+            else:
+                bits.append(" ")
+        # For tables with no data or field names
+        if not self._field_names:
+            if options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME):
+                bits.append(options["vertical_char"])
+            else:
+                bits.append(" ")
+        for field, width in zip(self._field_names, self._widths):
+            if options["fields"] and field not in options["fields"]:
+                continue
+            if self._header_style == "cap":
+                fieldname = field.capitalize()
+            elif self._header_style == "title":
+                fieldname = field.title()
+            elif self._header_style == "upper":
+                fieldname = field.upper()
+            elif self._header_style == "lower":
+                fieldname = field.lower()
+            else:
+                fieldname = field
+            if _str_block_width(fieldname) > width:
+                fieldname = fieldname[:width]
+            bits.append(
+                " " * lpad
+                + self._justify(fieldname, width, self._align[field])
+                + " " * rpad
+            )
+            if options["border"] or options["preserve_internal_border"]:
+                if options["vrules"] == VRuleStyle.ALL:
+                    bits.append(options["vertical_char"])
+                else:
+                    bits.append(" ")
+
+        # If only preserve_internal_border is true, then we just appended
+        # a vertical character at the end when we wanted a space
+        if not options["border"] and options["preserve_internal_border"]:
+            bits.pop()
+            bits.append(" ")
+        # If vrules is FRAME, then we just appended a space at the end
+        # of the last field, when we really want a vertical character
+        if options["border"] and options["vrules"] == VRuleStyle.FRAME:
+            bits.pop()
+            bits.append(options["vertical_char"])
+        if (options["border"] or options["preserve_internal_border"]) and options[
+            "hrules"
+        ] != HRuleStyle.NONE:
+            bits.append("\n")
+            bits.append(self._hrule)
+        return "".join(bits)
+
+    def _stringify_row(self, row: list[str], options: OptionsType, hrule: str) -> str:
+        import textwrap
+
+        for index, field, value, width in zip(
+            range(0, len(row)), self._field_names, row, self._widths
+        ):
+            # Enforce max widths
+            lines = value.split("\n")
+            new_lines: list[str] = []
+            for line in lines:
+                if (
+                    line == "None"
+                    and (none_val := self.none_format.get(field)) is not None
+                ):
+                    line = none_val
+                if _str_block_width(line) > width:
+                    line = textwrap.fill(line, width)
+                new_lines.append(line)
+            lines = new_lines
+            value = "\n".join(lines)
+            row[index] = value
+
+        row_height = 0
+        for c in row:
+            h = _get_size(c)[1]
+            if h > row_height:
+                row_height = h
+
+        bits: list[list[str]] = []
+        lpad, rpad = self._get_padding_widths(options)
+        for y in range(0, row_height):
+            bits.append([])
+            if options["border"]:
+                if options["vrules"] in (VRuleStyle.ALL, VRuleStyle.FRAME):
+                    bits[y].append(self.vertical_char)
+                else:
+                    bits[y].append(" ")
+
+        for field, value, width in zip(self._field_names, row, self._widths):
+            valign = self._valign[field]
+            lines = value.split("\n")
+            d_height = row_height - len(lines)
+            if d_height:
+                if valign == "m":
+                    lines = (
+                        [""] * int(d_height / 2)
+                        + lines
+                        + [""] * (d_height - int(d_height / 2))
+                    )
+                elif valign == "b":
+                    lines = [""] * d_height + lines
+                else:
+                    lines = lines + [""] * d_height
+
+            for y, line in enumerate(lines):
+                if options["fields"] and field not in options["fields"]:
+                    continue
+
+                bits[y].append(
+                    " " * lpad
+                    + self._justify(line, width, self._align[field])
+                    + " " * rpad
+                )
+                if options["border"] or options["preserve_internal_border"]:
+                    if options["vrules"] == VRuleStyle.ALL:
+                        bits[y].append(self.vertical_char)
+                    else:
+                        bits[y].append(" ")
+
+        # If only preserve_internal_border is true, then we just appended
+        # a vertical character at the end when we wanted a space
+        if not options["border"] and options["preserve_internal_border"]:
+            bits[-1].pop()
+            bits[-1].append(" ")
+
+        # If vrules is FRAME, then we just appended a space at the end
+        # of the last field, when we really want a vertical character
+        for y in range(0, row_height):
+            if options["border"] and options["vrules"] == VRuleStyle.FRAME:
+                bits[y].pop()
+                bits[y].append(options["vertical_char"])
+
+        if options["border"] and options["hrules"] == HRuleStyle.ALL:
+            bits[row_height - 1].append("\n")
+            bits[row_height - 1].append(hrule)
+
+        bits_str = ["".join(bits_y) for bits_y in bits]
+        return "\n".join(bits_str)
+
+    def paginate(self, page_length: int = 58, line_break: str = "\f", **kwargs) -> str:
+        pages: list[str] = []
+        kwargs["start"] = kwargs.get("start", 0)
+        true_end = kwargs.get("end", self.rowcount)
+        while True:
+            kwargs["end"] = min(kwargs["start"] + page_length, true_end)
+            pages.append(self.get_string(**kwargs))
+            if kwargs["end"] == true_end:
+                break
+            kwargs["start"] += page_length
+        return line_break.join(pages)
+
+    ##############################
+    # CSV STRING METHODS         #
+    ##############################
+    def get_csv_string(self, **kwargs) -> str:
+        """Return string representation of CSV formatted table in the current state
+
+        Keyword arguments are first interpreted as table formatting options, and
+        then any unused keyword arguments are passed to csv.writer(). For
+        example, get_csv_string(header=False, delimiter='\t') would use
+        header as a PrettyTable formatting option (skip the header row) and
+        delimiter as a csv.writer keyword argument.
+        """
+        import csv
+
+        options = self._get_options(kwargs)
+        csv_options = {
+            key: value for key, value in kwargs.items() if key not in options
+        }
+        csv_buffer = io.StringIO()
+        csv_writer = csv.writer(csv_buffer, **csv_options)
+
+        if options.get("header"):
+            if options["fields"]:
+                csv_writer.writerow(
+                    [f for f in self._field_names if f in options["fields"]]
+                )
+            else:
+                csv_writer.writerow(self._field_names)
+
+        rows = self._get_rows(options)
+        if options["fields"]:
+            rows = [
+                [d for f, d in zip(self._field_names, row) if f in options["fields"]]
+                for row in rows
+            ]
+        for row in rows:
+            csv_writer.writerow(row)
+
+        return csv_buffer.getvalue()
+
+    ##############################
+    # JSON STRING METHODS        #
+    ##############################
+    def get_json_string(self, **kwargs) -> str:
+        """Return string representation of JSON formatted table in the current state
+
+        Keyword arguments are first interpreted as table formatting options, and
+        then any unused keyword arguments are passed to json.dumps(). For
+        example, get_json_string(header=False, indent=2) would use header as
+        a PrettyTable formatting option (skip the header row) and indent as a
+        json.dumps keyword argument.
+        """
+        import json
+
+        options = self._get_options(kwargs)
+        json_options: dict[str, Any] = {
+            "indent": 4,
+            "separators": (",", ": "),
+            "sort_keys": True,
+        }
+        json_options.update(
+            {key: value for key, value in kwargs.items() if key not in options}
+        )
+        objects: list[list[str] | dict[str, Any]] = []
+
+        if options.get("header"):
+            if options["fields"]:
+                objects.append([f for f in self._field_names if f in options["fields"]])
+            else:
+                objects.append(self.field_names)
+        rows = self._get_rows(options)
+        if options["fields"]:
+            for row in rows:
+                objects.append(
+                    {
+                        f: d
+                        for f, d in zip(self._field_names, row)
+                        if f in options["fields"]
+                    }
+                )
+        else:
+            for row in rows:
+                objects.append(dict(zip(self._field_names, row)))
+
+        return json.dumps(objects, **json_options)
+
+    ##############################
+    # HTML STRING METHODS        #
+    ##############################
+
+    def get_html_string(self, **kwargs) -> str:
+        """Return string representation of HTML formatted version of table in current
+        state.
+
+        Arguments:
+
+        title - optional table title
+        start - index of first data row to include in output
+        end - index of last data row to include in output PLUS ONE (list slice style)
+        fields - names of fields (columns) to include
+        header - print a header showing field names (True or False)
+        escape_header - escapes the text within a header (True or False)
+        border - print a border around the table (True or False)
+        preserve_internal_border - print a border inside the table even if
+            border is disabled (True or False)
+        hrules - controls printing of horizontal rules after rows.
+            Allowed values: HRuleStyle
+        vrules - controls printing of vertical rules between columns.
+            Allowed values: VRuleStyle
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
+        custom_format - controls formatting of any column using callable
+        padding_width - number of spaces on either side of column data (only used if
+            left and right paddings are None)
+        left_padding_width - number of spaces on left hand side of column data
+        right_padding_width - number of spaces on right hand side of column data
+        sortby - name of field to sort rows by
+        sort_key - sorting key function, applied to data points before sorting
+        attributes - dictionary of name/value pairs to include as HTML attributes in the
+            <table> tag
+        format - Controls whether or not HTML tables are formatted to match
+            styling options (True or False)
+        escape_data - escapes the text within a data field (True or False)
+        xhtml - print <br/> tags if True, <br> tags if False"""
+
+        options = self._get_options(kwargs)
+
+        if options["format"]:
+            string = self._get_formatted_html_string(options)
+        else:
+            string = self._get_simple_html_string(options)
+
+        return string
+
+    def _get_simple_html_string(self, options: OptionsType) -> str:
+        from html import escape
+
+        lines: list[str] = []
+        if options["xhtml"]:
+            linebreak = "<br/>"
+        else:
+            linebreak = "<br>"
+
+        open_tag = ["<table"]
+        if options["attributes"]:
+            for attr_name, attr_value in options["attributes"].items():
+                open_tag.append(f' {escape(attr_name)}="{escape(attr_value)}"')
+        open_tag.append(">")
+        lines.append("".join(open_tag))
+
+        # Title
+        title = options["title"] or self._title
+        if title:
+            lines.append(f"    <caption>{escape(title)}</caption>")
+
+        # Headers
+        if options["header"]:
+            lines.append("    <thead>")
+            lines.append("        <tr>")
+            for field in self._field_names:
+                if options["fields"] and field not in options["fields"]:
+                    continue
+                if options["escape_header"]:
+                    field = escape(field)
+
+                lines.append(
+                    "            <th>{}</th>".format(field.replace("\n", linebreak))
+                )
+
+            lines.append("        </tr>")
+            lines.append("    </thead>")
+
+        # Data
+        lines.append("    <tbody>")
+        rows = self._get_rows(options)
+        formatted_rows = self._format_rows(rows)
+        for row in formatted_rows:
+            lines.append("        <tr>")
+            for field, datum in zip(self._field_names, row):
+                if options["fields"] and field not in options["fields"]:
+                    continue
+                if options["escape_data"]:
+                    datum = escape(datum)
+
+                lines.append(
+                    "            <td>{}</td>".format(datum.replace("\n", linebreak))
+                )
+            lines.append("        </tr>")
+        lines.append("    </tbody>")
+        lines.append("</table>")
+
+        return "\n".join(lines)
+
+    def _get_formatted_html_string(self, options: OptionsType) -> str:
+        from html import escape
+
+        lines: list[str] = []
+        lpad, rpad = self._get_padding_widths(options)
+        if options["xhtml"]:
+            linebreak = "<br/>"
+        else:
+            linebreak = "<br>"
+
+        open_tag = ["<table"]
+        if options["border"]:
+            if (
+                options["hrules"] == HRuleStyle.ALL
+                and options["vrules"] == VRuleStyle.ALL
+            ):
+                open_tag.append(' frame="box" rules="all"')
+            elif (
+                options["hrules"] == HRuleStyle.FRAME
+                and options["vrules"] == VRuleStyle.FRAME
+            ):
+                open_tag.append(' frame="box"')
+            elif (
+                options["hrules"] == HRuleStyle.FRAME
+                and options["vrules"] == VRuleStyle.ALL
+            ):
+                open_tag.append(' frame="box" rules="cols"')
+            elif options["hrules"] == HRuleStyle.FRAME:
+                open_tag.append(' frame="hsides"')
+            elif options["hrules"] == HRuleStyle.ALL:
+                open_tag.append(' frame="hsides" rules="rows"')
+            elif options["vrules"] == VRuleStyle.FRAME:
+                open_tag.append(' frame="vsides"')
+            elif options["vrules"] == VRuleStyle.ALL:
+                open_tag.append(' frame="vsides" rules="cols"')
+        if not options["border"] and options["preserve_internal_border"]:
+            open_tag.append(' rules="cols"')
+        if options["attributes"]:
+            for attr_name, attr_value in options["attributes"].items():
+                open_tag.append(f' {escape(attr_name)}="{escape(attr_value)}"')
+        open_tag.append(">")
+        lines.append("".join(open_tag))
+
+        # Title
+        title = options["title"] or self._title
+        if title:
+            lines.append(f"    <caption>{escape(title)}</caption>")
+
+        # Headers
+        if options["header"]:
+            lines.append("    <thead>")
+            lines.append("        <tr>")
+            for field in self._field_names:
+                if options["fields"] and field not in options["fields"]:
+                    continue
+                if options["escape_header"]:
+                    field = escape(field)
+
+                content = field.replace("\n", linebreak)
+                lines.append(
+                    f'            <th style="'
+                    f"padding-left: {lpad}em; "
+                    f"padding-right: {rpad}em; "
+                    f'text-align: center">{content}</th>'
+                )
+            lines.append("        </tr>")
+            lines.append("    </thead>")
+
+        # Data
+        lines.append("    <tbody>")
+        rows = self._get_rows(options)
+        formatted_rows = self._format_rows(rows)
+        aligns: list[str] = []
+        valigns: list[str] = []
+        for field in self._field_names:
+            aligns.append(
+                {"l": "left", "r": "right", "c": "center"}[self._align[field]]
+            )
+            valigns.append(
+                {"t": "top", "m": "middle", "b": "bottom"}[self._valign[field]]
+            )
+        for row in formatted_rows:
+            lines.append("        <tr>")
+            for field, datum, align, valign in zip(
+                self._field_names, row, aligns, valigns
+            ):
+                if options["fields"] and field not in options["fields"]:
+                    continue
+                if options["escape_data"]:
+                    datum = escape(datum)
+
+                content = datum.replace("\n", linebreak)
+                lines.append(
+                    f'            <td style="'
+                    f"padding-left: {lpad}em; "
+                    f"padding-right: {rpad}em; "
+                    f"text-align: {align}; "
+                    f'vertical-align: {valign}">{content}</td>'
+                )
+            lines.append("        </tr>")
+        lines.append("    </tbody>")
+        lines.append("</table>")
+
+        return "\n".join(lines)
+
+    ##############################
+    # LATEX STRING METHODS       #
+    ##############################
+
+    def get_latex_string(self, **kwargs) -> str:
+        """Return string representation of LaTex formatted version of table in current
+        state.
+
+        Arguments:
+
+        start - index of first data row to include in output
+        end - index of last data row to include in output PLUS ONE (list slice style)
+        fields - names of fields (columns) to include
+        header - print a header showing field names (True or False)
+        border - print a border around the table (True or False)
+        preserve_internal_border - print a border inside the table even if
+            border is disabled (True or False)
+        hrules - controls printing of horizontal rules after rows.
+            Allowed values: HRuleStyle
+        vrules - controls printing of vertical rules between columns.
+            Allowed values: VRuleStyle
+        int_format - controls formatting of integer data
+        float_format - controls formatting of floating point data
+        sortby - name of field to sort rows by
+        sort_key - sorting key function, applied to data points before sorting
+        format - Controls whether or not HTML tables are formatted to match
+            styling options (True or False)
+        """
+        options = self._get_options(kwargs)
+
+        if options["format"]:
+            string = self._get_formatted_latex_string(options)
+        else:
+            string = self._get_simple_latex_string(options)
+        return string
+
+    def _get_simple_latex_string(self, options: OptionsType) -> str:
+        lines: list[str] = []
+
+        wanted_fields = []
+        if options["fields"]:
+            wanted_fields = [
+                field for field in self._field_names if field in options["fields"]
+            ]
+        else:
+            wanted_fields = self._field_names
+
+        alignments = "".join([self._align[field] for field in wanted_fields])
+
+        begin_cmd = f"\\begin{{tabular}}{{{alignments}}}"
+        lines.append(begin_cmd)
+
+        # Headers
+        if options["header"]:
+            lines.append(" & ".join(wanted_fields) + " \\\\")
+
+        # Data
+        rows = self._get_rows(options)
+        formatted_rows = self._format_rows(rows)
+        for row in formatted_rows:
+            wanted_data = [
+                d for f, d in zip(self._field_names, row) if f in wanted_fields
+            ]
+            lines.append(" & ".join(wanted_data) + " \\\\")
+
+        lines.append("\\end{tabular}")
+
+        return "\r\n".join(lines)
+
+    def _get_formatted_latex_string(self, options: OptionsType) -> str:
+        lines: list[str] = []
+
+        wanted_fields: list[str] = []
+        if options["fields"]:
+            wanted_fields = [
+                field for field in self._field_names if field in options["fields"]
+            ]
+        else:
+            wanted_fields = self._field_names
+
+        wanted_alignments = [self._align[field] for field in wanted_fields]
+        if options["border"] and options["vrules"] == VRuleStyle.ALL:
+            alignment_str = "|".join(wanted_alignments)
+        elif not options["border"] and options["preserve_internal_border"]:
+            alignment_str = "|".join(wanted_alignments)
+        else:
+            alignment_str = "".join(wanted_alignments)
+
+        if options["border"] and options["vrules"] in [
+            VRuleStyle.ALL,
+            VRuleStyle.FRAME,
+        ]:
+            alignment_str = "|" + alignment_str + "|"
+
+        begin_cmd = f"\\begin{{tabular}}{{{alignment_str}}}"
+        lines.append(begin_cmd)
+        if options["border"] and options["hrules"] in [
+            HRuleStyle.ALL,
+            HRuleStyle.FRAME,
+        ]:
+            lines.append("\\hline")
+
+        # Headers
+        if options["header"]:
+            lines.append(" & ".join(wanted_fields) + " \\\\")
+        if (options["border"] or options["preserve_internal_border"]) and options[
+            "hrules"
+        ] in [HRuleStyle.ALL, HRuleStyle.HEADER]:
+            lines.append("\\hline")
+
+        # Data
+        rows = self._get_rows(options)
+        formatted_rows = self._format_rows(rows)
+        rows = self._get_rows(options)
+        for row in formatted_rows:
+            wanted_data = [
+                d for f, d in zip(self._field_names, row) if f in wanted_fields
+            ]
+            lines.append(" & ".join(wanted_data) + " \\\\")
+            if options["border"] and options["hrules"] == HRuleStyle.ALL:
+                lines.append("\\hline")
+
+        if options["border"] and options["hrules"] == HRuleStyle.FRAME:
+            lines.append("\\hline")
+
+        lines.append("\\end{tabular}")
+
+        return "\r\n".join(lines)
+
+
+##############################
+# UNICODE WIDTH FUNCTION     #
+##############################
+
+
+def _str_block_width(val: str) -> int:
+    import wcwidth  # type: ignore[import-untyped]
+
+    return wcwidth.wcswidth(_re.sub("", val))
+
+
+##############################
+# TABLE FACTORIES            #
+##############################
+
+
+def from_csv(fp, field_names: Sequence[str] | None = None, **kwargs) -> PrettyTable:
+    import csv
+
+    fmtparams = {}
+    for param in [
+        "delimiter",
+        "doublequote",
+        "escapechar",
+        "lineterminator",
+        "quotechar",
+        "quoting",
+        "skipinitialspace",
+        "strict",
+    ]:
+        if param in kwargs:
+            fmtparams[param] = kwargs.pop(param)
+    if fmtparams:
+        reader = csv.reader(fp, **fmtparams)
+    else:
+        dialect = csv.Sniffer().sniff(fp.read(1024))
+        fp.seek(0)
+        reader = csv.reader(fp, dialect)
+
+    table = PrettyTable(**kwargs)
+    if field_names:
+        table.field_names = field_names
+    else:
+        table.field_names = [x.strip() for x in next(reader)]
+
+    for row in reader:
+        table.add_row([x.strip() for x in row])
+
+    return table
+
+
+def from_db_cursor(cursor: Cursor, **kwargs) -> PrettyTable | None:
+    if cursor.description:
+        table = PrettyTable(**kwargs)
+        table.field_names = [col[0] for col in cursor.description]
+        for row in cursor.fetchall():
+            table.add_row(row)
+        return table
+    return None
+
+
+def from_json(json_string: str | bytes, **kwargs) -> PrettyTable:
+    import json
+
+    table = PrettyTable(**kwargs)
+    objects = json.loads(json_string)
+    table.field_names = objects[0]
+    for obj in objects[1:]:
+        row = [obj[key] for key in table.field_names]
+        table.add_row(row)
+    return table
+
+
+class TableHandler(HTMLParser):
+    def __init__(self, **kwargs) -> None:
+        HTMLParser.__init__(self)
+        self.kwargs = kwargs
+        self.tables: list[PrettyTable] = []
+        self.last_row: list[str] = []
+        self.rows: list[tuple[list[str], bool]] = []
+        self.max_row_width = 0
+        self.active: str | None = None
+        self.last_content = ""
+        self.is_last_row_header = False
+        self.colspan = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self.active = tag
+        if tag == "th":
+            self.is_last_row_header = True
+        for key, value in attrs:
+            if key == "colspan":
+                self.colspan = int(value)  # type: ignore[arg-type]
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in ["th", "td"]:
+            stripped_content = self.last_content.strip()
+            self.last_row.append(stripped_content)
+            if self.colspan:
+                for _ in range(1, self.colspan):
+                    self.last_row.append("")
+                self.colspan = 0
+
+        if tag == "tr":
+            self.rows.append((self.last_row, self.is_last_row_header))
+            self.max_row_width = max(self.max_row_width, len(self.last_row))
+            self.last_row = []
+            self.is_last_row_header = False
+        if tag == "table":
+            table = self.generate_table(self.rows)
+            self.tables.append(table)
+            self.rows = []
+        self.last_content = " "
+        self.active = None
+
+    def handle_data(self, data: str) -> None:
+        self.last_content += data
+
+    def generate_table(self, rows: list[tuple[list[str], bool]]) -> PrettyTable:
+        """
+        Generates from a list of rows a PrettyTable object.
+        """
+        table = PrettyTable(**self.kwargs)
+        for row in self.rows:
+            if len(row[0]) < self.max_row_width:
+                appends = self.max_row_width - len(row[0])
+                for i in range(1, appends):
+                    row[0].append("-")
+
+            if row[1]:
+                self.make_fields_unique(row[0])
+                table.field_names = row[0]
+            else:
+                table.add_row(row[0])
+        return table
+
+    def make_fields_unique(self, fields: list[str]) -> None:
+        """
+        iterates over the row and make each field unique
+        """
+        for i in range(0, len(fields)):
+            for j in range(i + 1, len(fields)):
+                if fields[i] == fields[j]:
+                    fields[j] += "'"
+
+
+def from_html(html_code: str, **kwargs) -> list[PrettyTable]:
+    """
+    Generates a list of PrettyTables from a string of HTML code. Each <table> in
+    the HTML becomes one PrettyTable object.
+    """
+
+    parser = TableHandler(**kwargs)
+    parser.feed(html_code)
+    return parser.tables
+
+
+def from_html_one(html_code: str, **kwargs) -> PrettyTable:
+    """
+    Generates a PrettyTable from a string of HTML code which contains only a
+    single <table>
+    """
+
+    tables = from_html(html_code, **kwargs)
+    try:
+        assert len(tables) == 1
+    except AssertionError:
+        msg = "More than one <table> in provided HTML code. Use from_html instead."
+        raise ValueError(msg)
+    return tables[0]
+
+
+def _warn_deprecation(name: str, module_globals: dict[str, Any]) -> Any:
+    if (val := module_globals.get(f"_DEPRECATED_{name}")) is None:
+        msg = f"module '{__name__}' has no attribute '{name}'"
+        raise AttributeError(msg)
+    module_globals[name] = val
+    if name in {"FRAME", "ALL", "NONE", "HEADER"}:
+        msg = (
+            f"the '{name}' constant is deprecated, "
+            "use the 'HRuleStyle' and 'VRuleStyle' enums instead"
+        )
+    else:
+        msg = f"the '{name}' constant is deprecated, use the 'TableStyle' enum instead"
+    warnings.warn(msg, DeprecationWarning, stacklevel=3)
+    return val
+
+
+def __getattr__(name: str) -> Any:
+    return _warn_deprecation(name, module_globals=globals())