numbers-parser 4.7.1__py3-none-any.whl → 4.8.0__py3-none-any.whl

numbers_parser/cell_storage.py

@@ -1,10 +1,9 @@
 import logging
 import math
 import re
-from collections import OrderedDict
 from fractions import Fraction
 from struct import unpack
-from typing import Tuple
+from typing import Tuple, Union
 from warnings import warn
 
 import sigfig
@@ -13,6 +12,8 @@ from pendulum import datetime, duration
 from numbers_parser import __name__ as numbers_parser_name
 from numbers_parser.constants import (
     CURRENCY_CELL_TYPE,
+    CUSTOM_TEXT_PLACEHOLDER,
+    DATETIME_FIELD_MAP,
     DECIMAL_PLACES_AUTO,
     EPOCH,
     MAX_SIGNIFICANT_DIGITS,
@@ -22,14 +23,14 @@ from numbers_parser.constants import (
     SECONDS_IN_WEEK,
     CellPadding,
     CellType,
+    CustomFormattingType,
     DurationStyle,
     DurationUnits,
+    FormattingType,
     FormatType,
-    NegativeNumberStyle,
 )
-from numbers_parser.currencies import CURRENCIES, CURRENCY_SYMBOLS
+from numbers_parser.currencies import CURRENCY_SYMBOLS
 from numbers_parser.exceptions import UnsupportedError, UnsupportedWarning
-from numbers_parser.generated import TSKArchives_pb2 as TSKArchives
 from numbers_parser.generated import TSTArchives_pb2 as TSTArchives
 from numbers_parser.numbers_cache import Cacheable, cache
 from numbers_parser.numbers_uuid import NumbersUUID
@@ -37,47 +38,6 @@ from numbers_parser.numbers_uuid import NumbersUUID
 logger = logging.getLogger(numbers_parser_name)
 debug = logger.debug
 
-DATETIME_FIELD_MAP = OrderedDict(
-    [
-        ("a", lambda x: x.strftime("%p").lower()),
-        ("EEEE", "%A"),
-        ("EEE", "%a"),
-        ("yyyy", "%Y"),
-        ("yy", "%y"),
-        ("y", "%Y"),
-        ("MMMM", "%B"),
-        ("MMM", "%b"),
-        ("MM", "%m"),
-        ("M", "%-m"),
-        ("d", "%-d"),
-        ("dd", "%d"),
-        ("DDD", lambda x: str(x.day_of_year).zfill(3)),
-        ("DD", lambda x: str(x.day_of_year).zfill(2)),
-        ("D", lambda x: str(x.day_of_year).zfill(1)),
-        ("HH", "%H"),
-        ("H", "%-H"),
-        ("hh", "%I"),
-        ("h", "%-I"),
-        ("k", lambda x: str(x.hour).replace("0", "24")),
-        ("kk", lambda x: str(x.hour).replace("0", "24").zfill(2)),
-        ("K", lambda x: str(x.hour % 12)),
-        ("KK", lambda x: str(x.hour % 12).zfill(2)),
-        ("mm", lambda x: str(x.minute).zfill(2)),
-        ("m", lambda x: str(x.minute)),
-        ("ss", "%S"),
-        ("s", lambda x: str(x.second)),
-        ("W", lambda x: str(x.week_of_month - 1)),
-        ("ww", "%W"),
-        ("G", "AD"),  # TODO: support BC
-        ("F", lambda x: days_occurred_in_month(x)),
-        ("S", lambda x: str(x.microsecond).zfill(6)[0]),
-        ("SS", lambda x: str(x.microsecond).zfill(6)[0:2]),
-        ("SSS", lambda x: str(x.microsecond).zfill(6)[0:3]),
-        ("SSSS", lambda x: str(x.microsecond).zfill(6)[0:4]),
-        ("SSSSS", lambda x: str(x.microsecond).zfill(6)[0:5]),
-    ]
-)
-
 
 class CellStorage(Cacheable):
     # 15% performance uplift for using slots
@@ -86,8 +46,8 @@ class CellStorage(Cacheable):
         "datetime",
         "model",
         "table_id",
-        "row_num",
-        "col_num",
+        "row",
+        "col",
         "value",
         "type",
         "d128",
@@ -117,13 +77,13 @@ class CellStorage(Cacheable):
 
     # @profile
     def __init__(  # noqa: PLR0912, PLR0913, PLR0915
-        self, model: object, table_id: int, buffer, row_num, col_num
+        self, model: object, table_id: int, buffer, row, col
     ):
         self.buffer = buffer
         self.model = model
         self.table_id = table_id
-        self.row_num = row_num
-        self.col_num = col_num
+        self.row = row
+        self.col = col
 
         self.d128 = None
         self.double = None
@@ -258,15 +218,41 @@ class CellStorage(Cacheable):
         else:
             raise UnsupportedError(f"Cell type ID {cell_type} is not recognised")
 
-        debug(
-            "cell@[%d,%d]: table_id=%d, type=%s, value=%s, flags=%0x",
-            row_num,
-            col_num,
-            table_id,
-            self.type.name,
-            self.value,
-            flags,
-        )
+        if logging.getLogger(__package__).level == logging.DEBUG:
+            # Guard to reduce expense of computing fields
+            extras = unpack("<H", buffer[6:8])[0]
+            table_name = model.table_name(table_id)
+            sheet_name = model.sheet_name(model.table_id_to_sheet_id(table_id))
+            fields = [
+                f"{x}=" + str(getattr(self, x)) if getattr(self, x) is not None else None
+                for x in self.__slots__
+                if x.endswith("_id")
+            ]
+            fields = ", ".join([x for x in fields if x if not None])
+            debug(
+                "%s@%s@[%d,%d]: table_id=%d, type=%s, value=%s, flags=%08x, extras=%04x, %s",
+                sheet_name,
+                table_name,
+                row,
+                col,
+                table_id,
+                self.type.name,
+                self.value,
+                flags,
+                extras,
+                fields,
+            )
+
+    def update_value(self, value, cell: object) -> None:
+        if cell._type == TSTArchives.numberCellType:
+            self.d128 = value
+            self.type = CellType.NUMBER
+        elif cell._type == TSTArchives.dateCellType:
+            self.datetime = value
+            self.type = CellType.DATE
+        elif cell._type == TSTArchives.durationCellType:
+            self.double = value
+        self.value = value
 
     @property
     def formatted(self):
@@ -309,7 +295,7 @@ class CellStorage(Cacheable):
         else:
             return (self.model.objects.file_store[image_pathnames[0]], preferred_filename)
 
-    def custom_format(self) -> str:
+    def custom_format(self) -> str:  # noqa: PLR0911
         if self.text_format_id is not None and self.type == CellType.TEXT:
             format = self.model.table_format(self.table_id, self.text_format_id)
         elif self.currency_format_id is not None:
@@ -320,17 +306,13 @@ class CellStorage(Cacheable):
             format = self.model.table_format(self.table_id, self.bool_format_id)
         else:
             return str(self.value)
+
         if format.HasField("custom_uid"):
             format_uuid = NumbersUUID(format.custom_uid).hex
             format_map = self.model.custom_format_map()
             custom_format = format_map[format_uuid].default_format
             if custom_format.requires_fraction_replacement:
-                accuracy = custom_format.fraction_accuracy
-                if accuracy & 0xFF000000:
-                    num_digits = 0x100000000 - accuracy
-                    formatted_value = float_to_n_digit_fraction(self.d128, num_digits)
-                else:
-                    formatted_value = float_to_fraction(self.d128, accuracy)
+                formatted_value = format_fraction(self.d128, custom_format)
             elif custom_format.format_type == FormatType.CUSTOM_TEXT:
                 formatted_value = decode_text_format(
                     custom_format,
@@ -346,6 +328,14 @@ class CellStorage(Cacheable):
             return format_currency(self.d128, format)
         elif format.format_type == FormatType.BOOLEAN:
             return "TRUE" if self.value else "FALSE"
+        elif format.format_type == FormatType.PERCENT:
+            return format_decimal(self.d128 * 100, format, percent=True)
+        elif format.format_type == FormatType.BASE:
+            return format_base(self.d128, format)
+        elif format.format_type == FormatType.FRACTION:
+            return format_fraction(self.d128, format)
+        elif format.format_type == FormatType.SCIENTIFIC:
+            return format_scientific(self.d128, format)
         else:
             formatted_value = str(self.value)
         return formatted_value
@@ -441,63 +431,18 @@ class CellStorage(Cacheable):
 
         return duration_str
 
-    def set_date_time_formatting(self, date_time_format) -> None:
-        check_date_time_format(date_time_format)
-        format_archive = TSKArchives.FormatStructArchive(
-            format_type=FormatType.DATE, date_time_format=date_time_format
-        )
-        self.date_format_id = self.model.table_format_id(self.table_id, format_archive)
-
-    def set_number_formatting(self, number_format) -> None:
-        check_number_format(number_format)
-        if "decimal_places" not in number_format or number_format["decimal_places"] is None:
-            decimal_places = DECIMAL_PLACES_AUTO
-        else:
-            decimal_places = number_format["decimal_places"]
-
-        if "negative_style" not in number_format:
-            negative_style = NegativeNumberStyle.MINUS
-        elif "use_accounting_style" in number_format:
-            warn(
-                "Use of use_accounting_style overrules negative_style",
-                RuntimeWarning,
-                stacklevel=4,
-            )
-            negative_style = NegativeNumberStyle.MINUS
-        else:
-            negative_style = number_format["negative_style"]
-
-        if "show_thousands_separator" not in number_format:
-            show_thousands_separator = False
-        else:
-            show_thousands_separator = number_format["show_thousands_separator"]
-
-        if "currency_code" in number_format:
-            format_type = FormatType.CURRENCY
-        else:
-            format_type = FormatType.DECIMAL
-
-        attrs = {
-            "format_type": format_type,
-            "decimal_places": decimal_places,
-            "negative_style": negative_style,
-            "show_thousands_separator": show_thousands_separator,
-        }
-
-        if format_type == FormatType.CURRENCY:
+    def _set_formatting(
+        self, format_id: int, format_type: Union[FormattingType, CustomFormattingType]
+    ) -> None:
+        if format_type == FormattingType.CURRENCY:
+            self.currency_format_id = format_id
             self.is_currency = True
-            if number_format["currency_code"] not in CURRENCIES:
-                currency_code = number_format["currency_code"]
-                raise TypeError(f"Unsupported currency code '{currency_code}'")
-            if "use_accounting_style" in number_format:
-                attrs["use_accounting_style"] = number_format["use_accounting_style"]
-            else:
-                attrs["use_accounting_style"] = False
-            attrs["currency_code"] = number_format["currency_code"]
+        elif format_type in [FormattingType.DATETIME, CustomFormattingType.DATETIME]:
+            self.date_format_id = format_id
+        elif format_type == CustomFormattingType.TEXT:
+            self.text_format_id = format_id
         else:
-            self.is_currency = False
-        format_archive = TSKArchives.FormatStructArchive(**attrs)
-        self.num_format_id = self.model.table_format_id(self.table_id, format_archive)
+            self.num_format_id = format_id
 
 
 def unpack_decimal128(buffer: bytearray) -> float:
@@ -512,12 +457,6 @@ def unpack_decimal128(buffer: bytearray) -> float:
     return float(value)
 
 
-def days_occurred_in_month(value: datetime) -> str:
-    """Return how many times the day of the datetime value has fallen in the month."""
-    n_days = int((value - value.replace(day=1)).days / 7) + 1
-    return str(n_days)
-
-
 def decode_date_format_field(field: str, value: datetime) -> str:
     if field in DATETIME_FIELD_MAP:
         s = DATETIME_FIELD_MAP[field]
@@ -581,7 +520,7 @@ def decode_date_format(format, value):
 def decode_text_format(format, value: str):
     """Parse a custom date format string and return a formatted number value."""
     custom_format_string = format.custom_format_string
-    return custom_format_string.replace("\ue421", value)
+    return custom_format_string.replace(CUSTOM_TEXT_PLACEHOLDER, value)
 
 
 def expand_quotes(value: str) -> str:
@@ -751,7 +690,7 @@ def decode_number_format(format, value, name):  # noqa: PLR0912
     return expand_quotes(formatted_value)
 
 
-def format_decimal(value: float, format) -> str:
+def format_decimal(value: float, format, percent: bool = False) -> str:
     if value is None:
         return ""
     if value < 0 and format.negative_style == 1:
@@ -782,6 +721,9 @@ def format_decimal(value: float, format) -> str:
             except ValueError:
                 pass
 
+    if percent:
+        formatted_value += "%"
+
     if accounting_style:
         return f"({formatted_value})"
     else:
@@ -802,17 +744,75 @@ def format_currency(value: float, format) -> str:
         return symbol + formatted_value
 
 
+INT_TO_BASE_CHAR = [str(x) for x in range(0, 10)] + [chr(x) for x in range(ord("A"), ord("Z") + 1)]
+
+
+def invert_bit_str(value: str) -> str:
+    """Invert a binary value"""
+    return "".join(["0" if b == "1" else "1" for b in value])
+
+
+def twos_complement(value: int, base: int) -> str:
+    """Calculate the twos complement of a negative integer with minimum 32-bit precision"""
+    num_bits = max([32, math.ceil(math.log2(abs(value))) + 1])
+    bin_value = bin(abs(value))[2:]
+    inverted_bin_value = invert_bit_str(bin_value).rjust(num_bits, "1")
+    twos_complement_dec = int(inverted_bin_value, 2) + 1
+
+    if base == 2:
+        return bin(twos_complement_dec)[2:].rjust(num_bits, "1")
+    elif base == 8:
+        return oct(twos_complement_dec)[2:]
+    else:
+        return hex(twos_complement_dec)[2:].upper()
+
+
+def format_base(value: float, format) -> str:
+    if value == 0:
+        return "0".zfill(format.base_places)
+
+    value = round(value)
+
+    is_negative = False
+    if not format.base_use_minus_sign and format.base in [2, 8, 16]:
+        if value < 0:
+            return twos_complement(value, format.base)
+        else:
+            value = abs(value)
+    elif value < 0:
+        is_negative = True
+        value = abs(value)
+
+    formatted_value = []
+    while value:
+        formatted_value.append(int(value % format.base))
+        value //= format.base
+    formatted_value = "".join([INT_TO_BASE_CHAR[x] for x in formatted_value[::-1]])
+
+    if is_negative:
+        return "-" + formatted_value.zfill(format.base_places)
+    else:
+        return formatted_value.zfill(format.base_places)
+
+
+def format_fraction_parts_to(whole: int, numerator: int, denominator: int):
+    if whole > 0:
+        if numerator == 0:
+            return str(whole)
+        else:
+            return f"{whole} {numerator}/{denominator}"
+    elif numerator == 0:
+        return "0"
+    elif numerator == denominator:
+        return "1"
+    return f"{numerator}/{denominator}"
+
+
 def float_to_fraction(value: float, denominator: int) -> str:
     """Convert a float to the nearest fraction and return as a string."""
     whole = int(value)
     numerator = round(denominator * (value - whole))
-    if numerator == 0:
-        formatted_value = "0"
-    elif whole > 0:
-        formatted_value = f"{whole} {numerator}/{denominator}"
-    else:
-        formatted_value = f"{numerator}/{denominator}"
-    return formatted_value
+    return format_fraction_parts_to(whole, numerator, denominator)
 
 
 def float_to_n_digit_fraction(value: float, max_digits: int) -> str:
@@ -825,13 +825,21 @@ def float_to_n_digit_fraction(value: float, max_digits: int) -> str:
     )
     whole = int(value)
     numerator -= whole * denominator
-    if numerator == 0:
-        formatted_value = "0"
-    elif whole == 0:
-        formatted_value = f"{numerator}/{denominator}"
+    return format_fraction_parts_to(whole, numerator, denominator)
+
+
+def format_fraction(value: float, format) -> str:
+    accuracy = format.fraction_accuracy
+    if accuracy & 0xFF000000:
+        num_digits = 0x100000000 - accuracy
+        return float_to_n_digit_fraction(value, num_digits)
     else:
-        formatted_value = f"{whole} {numerator}/{denominator}"
-    return formatted_value
+        return float_to_fraction(value, accuracy)
+
+
+def format_scientific(value: float, format) -> str:
+    formatted_value = sigfig.round(value, sigfigs=MAX_SIGNIFICANT_DIGITS, warn=False)
+    return f"{formatted_value:.{format.decimal_places}E}"
 
 
 def unit_format(unit: str, value: int, style: int, abbrev: str = None):
@@ -881,22 +889,3 @@ def auto_units(cell_value, format):
             unit_smallest = unit_largest
 
     return unit_smallest, unit_largest
-
-
-def check_date_time_format(format: str) -> None:
-    formats = re.sub(r"[^a-zA-Z\s]", " ", format).split()
-    for el in formats:
-        if el not in DATETIME_FIELD_MAP:
-            raise TypeError(f"Invalid format specifier '{el}' in date/time format")
-
-
-def check_number_format(format: dict) -> None:
-    for key in format:
-        if key not in [
-            "decimal_places",
-            "negative_style",
-            "show_thousands_separator",
-            "currency_code",
-            "use_accounting_style",
-        ]:
-            raise TypeError(f"Invalid format specifier '{key}' in number format")

numbers_parser/constants.py

@@ -1,5 +1,7 @@
+from collections import OrderedDict
 from enum import IntEnum
 
+import enum_tools.documentation
 from pendulum import datetime
 
 try:
@@ -8,6 +10,18 @@ try:
 except ImportError:  # pragma: nocover
     from importlib_resources import files
 
+__all__ = [
+    "CellType",
+    "PaddingType",
+    "CellPadding",
+    "DurationStyle",
+    "DurationUnits",
+    "FormatType",
+    "FormattingType",
+    "NegativeNumberStyle",
+    "FractionAccuracy",
+]
+
 DEFAULT_DOCUMENT = files("numbers_parser") / "data" / "empty.numbers"
 
 # New document defaults
@@ -16,7 +30,6 @@ DEFAULT_COLUMN_WIDTH = 98.0
 DEFAULT_PRE_BNC_BYTES = "🤠".encode()  # Yes, really!
 DEFAULT_ROW_COUNT = 12
 DEFAULT_ROW_HEIGHT = 20.0
-DEFAULT_NUM_HEADERS = 1
 DEFAULT_TABLE_OFFSET = 80.0
 DEFAULT_TILE_SIZE = 256
 
@@ -31,12 +44,16 @@ DEFAULT_TEXT_INSET = 4.0
 DEFAULT_TEXT_WRAP = True
 EMPTY_STORAGE_BUFFER = b"\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
 
+# Formatting defaults
+DEFAULT_DATETIME_FORMAT = "dd MMM YYY HH:MM"
+
 # Numbers limits
 MAX_TILE_SIZE = 256
 MAX_ROW_COUNT = 1000000
 MAX_COL_COUNT = 1000
 MAX_HEADER_COUNT = 5
 MAX_SIGNIFICANT_DIGITS = 15
+MAX_BASE = 36
 
 # Root object IDs
 DOCUMENT_ID = 1
@@ -51,6 +68,56 @@ SECONDS_IN_WEEK = SECONDS_IN_DAY * 7
 # File format enumerations
 DECIMAL_PLACES_AUTO = 253
 CURRENCY_CELL_TYPE = 10
+CUSTOM_TEXT_PLACEHOLDER = "\ue421"
+
+
+# Supported date/time directives
+def _days_occurred_in_month(value: datetime) -> str:
+    """Return how many times the day of the datetime value has fallen in the month."""
+    n_days = int((value - value.replace(day=1)).days / 7) + 1
+    return str(n_days)
+
+
+DATETIME_FIELD_MAP = OrderedDict(
+    [
+        ("a", lambda x: x.strftime("%p").lower()),
+        ("EEEE", "%A"),
+        ("EEE", "%a"),
+        ("yyyy", "%Y"),
+        ("yy", "%y"),
+        ("y", "%Y"),
+        ("MMMM", "%B"),
+        ("MMM", "%b"),
+        ("MM", "%m"),
+        ("M", "%-m"),
+        ("d", "%-d"),
+        ("dd", "%d"),
+        ("DDD", lambda x: str(x.day_of_year).zfill(3)),
+        ("DD", lambda x: str(x.day_of_year).zfill(2)),
+        ("D", lambda x: str(x.day_of_year).zfill(1)),
+        ("HH", "%H"),
+        ("H", "%-H"),
+        ("hh", "%I"),
+        ("h", "%-I"),
+        ("k", lambda x: str(x.hour).replace("0", "24")),
+        ("kk", lambda x: str(x.hour).replace("0", "24").zfill(2)),
+        ("K", lambda x: str(x.hour % 12)),
+        ("KK", lambda x: str(x.hour % 12).zfill(2)),
+        ("mm", lambda x: str(x.minute).zfill(2)),
+        ("m", lambda x: str(x.minute)),
+        ("ss", "%S"),
+        ("s", lambda x: str(x.second)),
+        ("W", lambda x: str(x.week_of_month - 1)),
+        ("ww", "%W"),
+        ("G", "AD"),  # TODO: support BC
+        ("F", lambda x: _days_occurred_in_month(x)),
+        ("S", lambda x: str(x.microsecond).zfill(6)[0]),
+        ("SS", lambda x: str(x.microsecond).zfill(6)[0:2]),
+        ("SSS", lambda x: str(x.microsecond).zfill(6)[0:3]),
+        ("SSSS", lambda x: str(x.microsecond).zfill(6)[0:4]),
+        ("SSSSS", lambda x: str(x.microsecond).zfill(6)[0:5]),
+    ]
+)
 
 
 class CellType(IntEnum):
@@ -90,6 +157,7 @@ class FormatType(IntEnum):
     DECIMAL = 256
     CURRENCY = 257
     PERCENT = 258
+    SCIENTIFIC = 259
     TEXT = 260
     DATE = 261
     FRACTION = 262
@@ -103,8 +171,104 @@ class FormatType(IntEnum):
     CUSTOM_CURRENCY = 274
 
 
+class FormattingType(IntEnum):
+    BASE = 1
+    CURRENCY = 2
+    DATETIME = 3
+    FRACTION = 4
+    NUMBER = 5
+    PERCENTAGE = 6
+    SCIENTIFIC = 7
+
+
+class CustomFormattingType(IntEnum):
+    NUMBER = 101
+    DATETIME = 102
+    TEXT = 103
+
+
+@enum_tools.documentation.document_enum
 class NegativeNumberStyle(IntEnum):
+    """
+    How negative numbers are formatted.
+
+    This enum is used in cell data formats and cell custom formats using the
+    `negative_style` keyword argument.
+    """
+
     MINUS = 0
+    """Negative numbers use a simple minus sign."""
     RED = 1
+    """Negative numbers are red with no minus sign."""
     PARENTHESES = 2
+    """Negative numbers are in parentheses with no minus sign."""
     RED_AND_PARENTHESES = 3
+    """Negative numbers are red and in parentheses with no minus sign."""
+
+
+@enum_tools.documentation.document_enum
+class FractionAccuracy(IntEnum):
+    """
+    How fractions are formatted.
+
+    This enum is used in cell data formats and cell custom formats using the
+    `fraction_accuracy` keyword argument.
+    """
+
+    THREE = 0xFFFFFFFD
+    """Fractions are formatted with up to 3 digits in the denominator."""
+    TWO = 0xFFFFFFFE
+    """Fractions are formatted with up to 2 digits in the denominator."""
+    ONE = 0xFFFFFFFF
+    """Fractions are formatted with up to 1 digit in the denominator."""
+    HALVES = 2
+    """Fractions are formatted to the nearest half."""
+    QUARTERS = 4
+    """Fractions are formatted to the nearest quarter."""
+    EIGTHS = 8
+    """Fractions are formatted to the nearest eighth."""
+    SIXTEENTHS = 16
+    """Fractions are formatted to the nearest sixteenth."""
+    TENTHS = 10
+    """Fractions are formatted to the nearest tenth."""
+    HUNDRETHS = 100
+    """Fractions are formatted to the nearest hundredth."""
+
+
+ALLOWED_FORMATTING_PARAMETERS = {
+    FormattingType.BASE: ["base", "base_places", "base_use_minus_sign"],
+    FormattingType.CURRENCY: [
+        "decimal_places",
+        "show_thousands_separator",
+        "negative_style",
+        "use_accounting_style",
+        "currency_code",
+    ],
+    FormattingType.DATETIME: ["date_time_format"],
+    FormattingType.FRACTION: ["fraction_accuracy"],
+    FormattingType.NUMBER: ["decimal_places", "show_thousands_separator", "negative_style"],
+    FormattingType.PERCENTAGE: ["decimal_places", "show_thousands_separator", "negative_style"],
+    FormattingType.SCIENTIFIC: ["decimal_places"],
+}
+
+FORMAT_TYPE_MAP = {
+    FormattingType.BASE: FormatType.BASE,
+    FormattingType.CURRENCY: FormatType.CURRENCY,
+    FormattingType.DATETIME: FormatType.DATE,
+    FormattingType.FRACTION: FormatType.FRACTION,
+    FormattingType.NUMBER: FormatType.DECIMAL,
+    FormattingType.PERCENTAGE: FormatType.PERCENT,
+    FormattingType.SCIENTIFIC: FormatType.SCIENTIFIC,
+}
+
+CUSTOM_FORMAT_TYPE_MAP = {
+    CustomFormattingType.NUMBER: FormatType.CUSTOM_NUMBER,
+    CustomFormattingType.DATETIME: FormatType.CUSTOM_DATE,
+    CustomFormattingType.TEXT: FormatType.CUSTOM_TEXT,
+}
+
+
+class PaddingType(IntEnum):
+    NONE = 0
+    ZEROS = 1
+    SPACES = 2